@defisaver/positions-sdk 2.1.59 → 2.1.61-aave-v4-dev

package/cjs/spark/index.js

@@ -233,6 +233,7 @@ exports.EMPTY_SPARK_DATA = {
     suppliedCollateralUsd: '0',
     totalSupplied: '0',
     eModeCategories: [],
+    exposure: 'N/A',
 };
 const _getSparkAccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
     let balances = {

package/cjs/types/aave.d.ts

@@ -162,6 +162,7 @@ export interface AaveV3AggregatedPositionData {
     liqRatio: string;
     liqPercent: string;
     leveragedType: LeverageType;
+    exposure: string;
     leveragedAsset?: string;
     liquidationPrice?: string;
     minCollRatio?: string;

package/cjs/types/aaveV4.d.ts

@@ -0,0 +1,139 @@
+import { EthAddress, IncentiveData, LeverageType, NetworkNumber } from './common';
+export declare enum AaveV4SpokesType {
+    AaveV4CoreSpoke = "aave_v4_core_spoke",
+    AaveV4YieldSeekingSpoke = "aave_v4_yield_seeking_spoke"
+}
+export declare enum AaveV4HubsType {
+    AaveV4CoreHub = "aave_v4_core_hub",
+    AaveV4YieldSeekingHub = "aave_v4_yield_seeking_hub"
+}
+export interface AaveV4SpokeInfo {
+    chainIds: NetworkNumber[];
+    label: string;
+    value: AaveV4SpokesType;
+    url: string;
+    address: EthAddress;
+    hubs: EthAddress[];
+}
+export interface AaveV4HubInfo {
+    chainIds: NetworkNumber[];
+    label: string;
+    value: AaveV4HubsType;
+    address: EthAddress;
+}
+export interface AaveV4HubAssetOnChainData {
+    assetId: number;
+    drawnRate: bigint;
+}
+export interface AaveV4HubOnChainData {
+    assets: Record<number, AaveV4HubAssetOnChainData>;
+}
+export interface AaveV4ReserveAssetOnChain {
+    underlying: EthAddress;
+    hub: EthAddress;
+    assetId: number;
+    decimals: number;
+    paused: boolean;
+    frozen: boolean;
+    borrowable: boolean;
+    collateralRisk: number;
+    collateralFactor: number;
+    maxLiquidationBonus: number;
+    liquidationFee: number;
+    price: bigint;
+    totalSupplied: bigint;
+    totalDrawn: bigint;
+    totalPremium: bigint;
+    totalDebt: bigint;
+    supplyCap: bigint;
+    borrowCap: bigint;
+    deficitRay: bigint;
+    spokeActive: boolean;
+    spokePaused: boolean;
+}
+export interface AaveV4ReserveAssetData {
+    symbol: string;
+    underlying: EthAddress;
+    hub: EthAddress;
+    hubName: string;
+    assetId: number;
+    reserveId: number;
+    paused: boolean;
+    frozen: boolean;
+    borrowable: boolean;
+    collateralRisk: number;
+    collateralFactor: number;
+    liquidationFee: number;
+    price: string;
+    totalSupplied: string;
+    totalDrawn: string;
+    totalPremium: string;
+    totalDebt: string;
+    supplyCap: string;
+    borrowCap: string;
+    spokeActive: boolean;
+    spokePaused: boolean;
+    drawnRate: string;
+    supplyRate: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
+    canBeBorrowed: boolean;
+    canBeSupplied: boolean;
+    canBeWithdrawn: boolean;
+    canBePayBacked: boolean;
+    utilization: string;
+}
+export type AaveV4AssetsData = Record<string, AaveV4ReserveAssetData>;
+export interface AaveV4SpokeData {
+    assetsData: AaveV4AssetsData;
+    oracle: EthAddress;
+    oracleDecimals: number;
+    address: EthAddress;
+}
+export interface AaveV4UsedReserveAsset {
+    symbol: string;
+    hubName: string;
+    assetId: number;
+    reserveId: number;
+    supplied: string;
+    suppliedUsd: string;
+    drawn: string;
+    drawnUsd: string;
+    premium: string;
+    premiumUsd: string;
+    borrowed: string;
+    borrowedUsd: string;
+    isSupplied: boolean;
+    isBorrowed: boolean;
+    collateral: boolean;
+    collateralFactor: number;
+}
+export interface AaveV4AggregatedPositionData {
+    suppliedUsd: string;
+    suppliedCollateralUsd: string;
+    borrowLimitUsd: string;
+    liquidationLimitUsd: string;
+    borrowedUsd: string;
+    drawnUsd: string;
+    premiumUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    collRatio: string;
+    liqRatio: string;
+    liqPercent: string;
+    leveragedType: LeverageType;
+    leveragedAsset: string;
+    liquidationPrice: string;
+    minCollRatio: string;
+    collLiquidationRatio: string;
+    minHealthRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    currentVolatilePairRatio?: string;
+}
+export type AaveV4UsedReserveAssets = Record<string, AaveV4UsedReserveAsset>;
+export interface AaveV4AccountData extends AaveV4AggregatedPositionData {
+    usedAssets: AaveV4UsedReserveAssets;
+    healthFactor: string;
+}

package/cjs/types/aaveV4.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AaveV4HubsType = exports.AaveV4SpokesType = void 0;
+var AaveV4SpokesType;
+(function (AaveV4SpokesType) {
+    AaveV4SpokesType["AaveV4CoreSpoke"] = "aave_v4_core_spoke";
+    AaveV4SpokesType["AaveV4YieldSeekingSpoke"] = "aave_v4_yield_seeking_spoke";
+})(AaveV4SpokesType || (exports.AaveV4SpokesType = AaveV4SpokesType = {}));
+var AaveV4HubsType;
+(function (AaveV4HubsType) {
+    AaveV4HubsType["AaveV4CoreHub"] = "aave_v4_core_hub";
+    AaveV4HubsType["AaveV4YieldSeekingHub"] = "aave_v4_yield_seeking_hub";
+})(AaveV4HubsType || (exports.AaveV4HubsType = AaveV4HubsType = {}));

package/cjs/types/common.d.ts

@@ -90,6 +90,7 @@ export interface MMPositionData {
     usedAssets: any;
     netApy: string;
     lastUpdated: number;
+    exposure: string;
 }
 export type Balances = Record<AssetSymbol, Amount>;
 export interface PositionBalances {

package/cjs/types/compound.d.ts

@@ -103,6 +103,7 @@ export interface CompoundAggregatedPositionData {
     minDebt: string;
     minCollRatio: string;
     collLiquidationRatio: string;
+    exposure: string;
 }
 export interface CompoundPositionData extends MMPositionData {
     ratio: string;

package/cjs/types/curveUsd.d.ts

@@ -72,6 +72,7 @@ export interface CrvUSDAggregatedPositionData {
     minAllowedRatio: number;
     collFactor: string;
     leveragedType: LeverageType;
+    exposure: string;
     leveragedAsset?: string;
     liquidationPrice?: string;
 }
@@ -111,4 +112,5 @@ export interface CrvUSDUserData {
     borrowRate?: string;
     collateralPrice: string;
     collRatio: string;
+    exposure: string;
 }

package/cjs/types/euler.d.ts

@@ -149,4 +149,5 @@ export interface EulerV2AggregatedPositionData {
     minDebt: string;
     minCollRatio: string;
     collLiquidationRatio: string;
+    exposure: string;
 }

package/cjs/types/fluid.d.ts

@@ -329,6 +329,7 @@ export interface FluidAggregatedVaultData {
     currentVolatilePairRatio?: string;
     minCollRatio?: string;
     collLiquidationRatio?: string;
+    exposure: string;
 }
 export interface BaseFluidVaultData {
     owner: string;

package/cjs/types/index.d.ts

@@ -14,3 +14,4 @@ export * from './merit';
 export * from './merkl';
 export * from './savings';
 export * from './common';
+export * from './aaveV4';

package/cjs/types/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./merit"), exports);
 __exportStar(require("./merkl"), exports);
 __exportStar(require("./savings"), exports);
 __exportStar(require("./common"), exports);
+__exportStar(require("./aaveV4"), exports);

package/cjs/types/liquity.d.ts

@@ -26,4 +26,5 @@ export interface LiquityTroveInfo {
     minCollateralRatio: number;
     priceForRecovery: string;
     debtInFront: string;
+    exposure: string;
 }

package/cjs/types/liquityV2.d.ts

@@ -93,6 +93,7 @@ export interface LiquityV2AggregatedTroveData {
     liquidationPrice: string;
     ratio: string;
     collRatio: string;
+    exposure: string;
 }
 export interface LiquityV2TroveData {
     usedAssets: LiquityV2UsedAssets;
@@ -115,4 +116,5 @@ export interface LiquityV2TroveData {
     liquidationPrice: string;
     debtInFront: string;
     lastInterestRateAdjTime: string;
+    exposure: string;
 }

package/cjs/types/llamaLend.d.ts

@@ -118,6 +118,7 @@ export interface LlamaLendAggregatedPositionData {
     netApy: string;
     incentiveUsd: string;
     totalInterestUsd: string;
+    exposure: string;
 }
 export interface LlamaLendUsedAsset {
     isSupplied: boolean;
@@ -155,4 +156,5 @@ export interface LlamaLendUserData {
     userBands: UserBandData[];
     loanExists: boolean;
     borrowRate?: string;
+    exposure: string;
 }

package/cjs/types/maker.d.ts

@@ -57,4 +57,5 @@ export interface CdpData {
     globalDebtCurrent: string;
     liquidationFee: string;
     lastUpdated: number;
+    exposure: string;
 }

package/cjs/types/morphoBlue.d.ts

@@ -135,6 +135,7 @@ export interface MorphoBlueAggregatedPositionData {
     liquidationPrice?: string;
     minCollRatio?: string;
     collLiquidationRatio?: string;
+    exposure: string;
 }
 export interface MorphoBluePositionData {
     usedAssets: MMUsedAssets;
@@ -156,6 +157,7 @@ export interface MorphoBluePositionData {
     liquidationPrice?: string;
     supplyShares: string;
     borrowShares: string;
+    exposure: string;
 }
 export interface MorphoBlueVault {
     address: string;

package/cjs/types/portfolio.d.ts

@@ -1,4 +1,5 @@
 import { AaveV2PositionData, AaveV3PositionData, AaveVersions } from './aave';
+import { AaveV4AccountData, AaveV4SpokesType } from './aaveV4';
 import { EthAddress } from './common';
 import { CompoundV2PositionData, CompoundV3PositionData, CompoundVersions } from './compound';
 import { CrvUSDUserData, CrvUSDVersions } from './curveUsd';
@@ -51,6 +52,9 @@ export interface PortfolioPositionsDataForAddress {
             [key: string]: FluidVaultData;
         };
     };
+    aaveV4: {
+        [key in AaveV4SpokesType]?: PortfolioProtocolData<AaveV4AccountData>;
+    };
 }
 export interface PortfolioPositionsData {
     [key: EthAddress]: PortfolioPositionsDataForAddress;

package/cjs/types/spark.d.ts

@@ -98,6 +98,7 @@ export interface SparkAggregatedPositionData {
     collLiquidationRatio: string;
     healthRatio: string;
     minHealthRatio: string;
+    exposure: string;
 }
 export interface SparkPositionData extends MMPositionData {
     ratio: string;

package/esm/aaveV3/index.d.ts

@@ -28,6 +28,7 @@ export declare const EMPTY_AAVE_DATA: {
     eModeCategories: never[];
     collRatio: string;
     suppliedCollateralUsd: string;
+    exposure: string;
 };
 export declare const _getAaveV3AccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
 export declare const getAaveV3AccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;

package/esm/aaveV3/index.js

@@ -321,6 +321,7 @@ export const EMPTY_AAVE_DATA = {
     eModeCategories: [],
     collRatio: '0',
     suppliedCollateralUsd: '0',
+    exposure: 'N/A',
 };
 export const _getAaveV3AccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
     let balances = {

package/esm/aaveV4/index.d.ts

@@ -0,0 +1,7 @@
+import { Client } from 'viem';
+import { AaveV4AccountData, AaveV4SpokeData, AaveV4SpokeInfo } from '../types';
+import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+export declare function _getAaveV4SpokeData(provider: Client, network: NetworkNumber, market: AaveV4SpokeInfo, blockNumber?: 'latest' | number): Promise<AaveV4SpokeData>;
+export declare function getAaveV4SpokeData(provider: EthereumProvider, network: NetworkNumber, spoke: AaveV4SpokeInfo, blockNumber?: 'latest' | number): Promise<AaveV4SpokeData>;
+export declare function _getAaveV4AccountData(provider: Client, network: NetworkNumber, spokeData: AaveV4SpokeData, address: EthAddress, blockNumber?: 'latest' | number): Promise<AaveV4AccountData>;
+export declare function getAaveV4AccountData(provider: EthereumProvider, network: NetworkNumber, marketData: AaveV4SpokeData, address: EthAddress, blockNumber?: 'latest' | number): Promise<any>;

package/esm/aaveV4/index.js

@@ -0,0 +1,165 @@
+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 { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { getViemProvider } from '../services/viem';
+import { IncentiveKind, } from '../types/common';
+import { AaveV4ViewContractViem } from '../contracts';
+import { getStakingApy, STAKING_ASSETS } from '../staking';
+import { wethToEth } from '../services/utils';
+import { aaveV4GetAggregatedPositionData } from '../helpers/aaveV4Helpers';
+import { getAaveV4HubByAddress } from '../markets/aaveV4';
+const fetchHubData = (viewContract, hubAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const hubData = yield viewContract.read.getHubAllAssetsData([hubAddress]);
+    return {
+        assets: hubData.reduce((acc, assetOnChainData) => {
+            acc[assetOnChainData.assetId] = {
+                assetId: assetOnChainData.assetId,
+                drawnRate: assetOnChainData.drawnRate,
+            };
+            return acc;
+        }, {}),
+    };
+});
+const formatReserveAsset = (reserveAsset, hubAsset, reserveId, oracleDecimals, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const assetInfo = getAssetInfoByAddress(reserveAsset.underlying, network);
+    const symbol = wethToEth(assetInfo.symbol);
+    const hubInfo = getAaveV4HubByAddress(network, reserveAsset.hub);
+    if (!hubInfo) {
+        throw new Error(`Hub not found with address: ${reserveAsset.hub}`);
+    }
+    const isStakingAsset = STAKING_ASSETS.includes(symbol);
+    const supplyIncentives = [];
+    const borrowIncentives = [];
+    if (isStakingAsset) {
+        const yieldApy = yield getStakingApy(symbol, network);
+        supplyIncentives.push({
+            apy: yieldApy,
+            token: symbol,
+            incentiveKind: IncentiveKind.Staking,
+            description: `Native ${symbol} yield.`,
+        });
+        if (reserveAsset.borrowable) {
+            // when borrowing assets whose value increases over time
+            borrowIncentives.push({
+                apy: new Dec(yieldApy).mul(-1).toString(),
+                token: symbol,
+                incentiveKind: IncentiveKind.Reward,
+                description: `Due to the native yield of ${symbol}, the value of the debt would increase over time.`,
+            });
+        }
+    }
+    return ({
+        symbol,
+        underlying: reserveAsset.underlying,
+        hub: hubInfo.address,
+        hubName: hubInfo === null || hubInfo === void 0 ? void 0 : hubInfo.label,
+        assetId: reserveAsset.assetId,
+        reserveId,
+        paused: reserveAsset.paused,
+        frozen: reserveAsset.frozen,
+        borrowable: reserveAsset.borrowable,
+        collateralRisk: new Dec(reserveAsset.collateralRisk).div(10000).toNumber(),
+        collateralFactor: new Dec(reserveAsset.collateralFactor).div(10000).toNumber(),
+        liquidationFee: new Dec(reserveAsset.liquidationFee).div(10000).toNumber(),
+        price: new Dec(reserveAsset.price).div(new Dec(10).pow(oracleDecimals)).toString(),
+        totalSupplied: assetAmountInEth(reserveAsset.totalSupplied.toString(), symbol),
+        totalDrawn: assetAmountInEth(reserveAsset.totalDrawn.toString(), symbol),
+        totalPremium: assetAmountInEth(reserveAsset.totalPremium.toString(), symbol),
+        totalDebt: assetAmountInEth(reserveAsset.totalDebt.toString(), symbol),
+        supplyCap: assetAmountInEth(reserveAsset.supplyCap.toString(), symbol),
+        borrowCap: assetAmountInEth(reserveAsset.borrowCap.toString(), symbol),
+        spokeActive: reserveAsset.spokeActive,
+        spokePaused: reserveAsset.spokePaused,
+        drawnRate: new Dec(hubAsset.drawnRate).div(new Dec(10).pow(27)).toString(),
+        supplyRate: '0', // To be implemented
+        supplyIncentives,
+        borrowIncentives,
+        canBeBorrowed: reserveAsset.spokeActive && !reserveAsset.spokePaused && !reserveAsset.paused && !reserveAsset.frozen,
+        canBeSupplied: reserveAsset.spokeActive && !reserveAsset.spokePaused && !reserveAsset.paused && !reserveAsset.frozen,
+        canBeWithdrawn: reserveAsset.spokeActive && !reserveAsset.spokePaused && !reserveAsset.paused,
+        canBePayBacked: reserveAsset.spokeActive && !reserveAsset.spokePaused && !reserveAsset.paused,
+        utilization: new Dec(reserveAsset.totalDrawn.toString()).times(100).div(new Dec(reserveAsset.totalSupplied.toString())).toString(),
+    });
+});
+export function _getAaveV4SpokeData(provider_1, network_1, market_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, market, blockNumber = 'latest') {
+        const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
+        const hubsData = {};
+        const [spokeData] = yield Promise.all([
+            viewContract.read.getSpokeDataFull([market.address]),
+            ...market.hubs.map((hubAddress) => __awaiter(this, void 0, void 0, function* () {
+                hubsData[hubAddress] = yield fetchHubData(viewContract, hubAddress);
+            })),
+        ]);
+        const reserveAssetsArray = yield Promise.all(spokeData[1].map((reserveAssetOnChain, index) => __awaiter(this, void 0, void 0, function* () { return formatReserveAsset(reserveAssetOnChain, hubsData[reserveAssetOnChain.hub].assets[reserveAssetOnChain.assetId], index, +spokeData[0].oracleDecimals.toString(), network); })));
+        return {
+            assetsData: reserveAssetsArray.reduce((acc, reserveAsset) => {
+                acc[`${reserveAsset.symbol}-${reserveAsset.reserveId}`] = reserveAsset;
+                return acc;
+            }, {}),
+            oracle: spokeData[0].oracle,
+            oracleDecimals: +spokeData[0].oracleDecimals.toString(),
+            address: market.address,
+        };
+    });
+}
+export function getAaveV4SpokeData(provider_1, network_1, spoke_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, spoke, blockNumber = 'latest') {
+        return _getAaveV4SpokeData(getViemProvider(provider, network), network, spoke, blockNumber);
+    });
+}
+export function _getAaveV4AccountData(provider_1, network_1, spokeData_1, address_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, spokeData, address, blockNumber = 'latest') {
+        const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
+        const loanData = yield viewContract.read.getLoanData([spokeData.address, address]);
+        const healthFactor = new Dec(loanData.healthFactor).div(1e18).toString();
+        const usedAssets = loanData.reserves.reduce((acc, usedReserveAsset) => {
+            const identifier = `${wethToEth(getAssetInfoByAddress(usedReserveAsset.underlying, network).symbol)}-${+usedReserveAsset.reserveId.toString()}`;
+            const reserveData = spokeData.assetsData[identifier];
+            const price = reserveData.price;
+            const supplied = assetAmountInEth(usedReserveAsset.supplied.toString(), reserveData.symbol);
+            const drawn = assetAmountInEth(usedReserveAsset.drawn.toString(), reserveData.symbol);
+            const premium = assetAmountInEth(usedReserveAsset.premium.toString(), reserveData.symbol);
+            const borrowed = assetAmountInEth(usedReserveAsset.totalDebt.toString(), reserveData.symbol);
+            acc[identifier] = {
+                symbol: reserveData.symbol,
+                hubName: reserveData.hubName,
+                assetId: reserveData.assetId,
+                reserveId: +usedReserveAsset.reserveId.toString(),
+                supplied,
+                suppliedUsd: new Dec(supplied).mul(price).toString(),
+                drawn,
+                drawnUsd: new Dec(drawn).mul(price).toString(),
+                premium,
+                premiumUsd: new Dec(premium).mul(price).toString(),
+                borrowed,
+                borrowedUsd: new Dec(borrowed).mul(price).toString(),
+                isSupplied: !new Dec(supplied).eq(0),
+                isBorrowed: usedReserveAsset.isBorrowing,
+                collateral: usedReserveAsset.isUsingAsCollateral,
+                collateralFactor: new Dec(usedReserveAsset.collateralFactor).div(10000).toNumber(),
+            };
+            return acc;
+        }, {});
+        return Object.assign({ usedAssets,
+            healthFactor }, aaveV4GetAggregatedPositionData({
+            usedAssets,
+            assetsData: spokeData.assetsData,
+            network,
+            useUserCollateralFactor: true,
+        }));
+    });
+}
+export function getAaveV4AccountData(provider_1, network_1, marketData_1, address_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, marketData, address, blockNumber = 'latest') {
+        return _getAaveV4AccountData(getViemProvider(provider, network), network, marketData, address, blockNumber);
+    });
+}

package/esm/compoundV2/index.d.ts

@@ -15,6 +15,7 @@ export declare const EMPTY_COMPOUND_DATA: {
     incentiveUsd: string;
     totalInterestUsd: string;
     borrowStableSupplyUnstable: boolean;
+    exposure: string;
 };
 export declare const _getCompoundV2AccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
 export declare const getCompoundV2AccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;

package/esm/compoundV2/index.js

@@ -91,6 +91,7 @@ export const EMPTY_COMPOUND_DATA = {
     incentiveUsd: '0',
     totalInterestUsd: '0',
     borrowStableSupplyUnstable: false,
+    exposure: 'N/A',
 };
 const getCollateralAssetsAddresses = (provider, network, account) => __awaiter(void 0, void 0, void 0, function* () {
     const contract = ComptrollerContractViem(provider, network);

package/esm/compoundV3/index.d.ts

@@ -18,6 +18,7 @@ export declare const EMPTY_COMPOUND_V3_DATA: {
     automationResubscribeRequired: boolean;
     isAllowed: boolean;
     lastUpdated: number;
+    exposure: string;
 };
 export declare const EMPTY_USED_ASSET: {
     isSupplied: boolean;

package/esm/compoundV3/index.js

@@ -83,6 +83,7 @@ export const EMPTY_COMPOUND_V3_DATA = {
     automationResubscribeRequired: false,
     isAllowed: false,
     lastUpdated: Date.now(),
+    exposure: 'N/A',
 };
 export const EMPTY_USED_ASSET = {
     isSupplied: false,