@defisaver/positions-sdk 2.1.51 → 2.1.52-aave-v4-1-dev

package/esm/contracts.js

@@ -132,3 +132,4 @@ export const StkAAVEViem = createViemContractFromConfigFunc('StkAAVE');
 export const YearnViewContractViem = createViemContractFromConfigFunc('YearnView');
 export const MakerDsrContractViem = createViemContractFromConfigFunc('MakerDsr');
 export const SkySavingsContractView = createViemContractFromConfigFunc('SkySavings');
+export const AaveV4ViewContractViem = createViemContractFromConfigFunc('AaveV4View');

package/esm/fluid/index.d.ts

@@ -130,10 +130,10 @@ export declare const _getUserPositions: (provider: PublicClient, network: Networ
         collRatio: string;
         minRatio: string;
         totalInterestUsd: string;
-        leveragedType?: string;
+        leveragedType?: import("../types").LeverageType;
         leveragedAsset?: string;
         liquidationPrice?: string;
-        leveragedLsdAssetRatio?: string;
+        currentVolatilePairRatio?: string;
         minCollRatio?: string;
         collLiquidationRatio?: string;
         owner: string;
@@ -161,10 +161,10 @@ export declare const getUserPositions: (provider: EthereumProvider, network: Net
         collRatio: string;
         minRatio: string;
         totalInterestUsd: string;
-        leveragedType?: string;
+        leveragedType?: import("../types").LeverageType;
         leveragedAsset?: string;
         liquidationPrice?: string;
-        leveragedLsdAssetRatio?: string;
+        currentVolatilePairRatio?: string;
         minCollRatio?: string;
         collLiquidationRatio?: string;
         owner: string;
@@ -192,10 +192,10 @@ export declare const _getUserPositionsPortfolio: (provider: PublicClient, networ
         collRatio: string;
         minRatio: string;
         totalInterestUsd: string;
-        leveragedType?: string;
+        leveragedType?: import("../types").LeverageType;
         leveragedAsset?: string;
         liquidationPrice?: string;
-        leveragedLsdAssetRatio?: string;
+        currentVolatilePairRatio?: string;
         minCollRatio?: string;
         collLiquidationRatio?: string;
         owner: string;

package/esm/helpers/aaveHelpers/index.d.ts

@@ -1,4 +1,4 @@
-import { AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAssets, AaveVersions } from '../../types';
+import { AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAsset, AaveV3UsedAssets, AaveVersions } from '../../types';
 import { EthereumProvider, NetworkNumber } from '../../types/common';
 export declare const AAVE_V3_MARKETS: AaveVersions[];
 export declare const isAaveV2: ({ selectedMarket }: {
@@ -17,7 +17,7 @@ export declare const aaveV3IsInSiloedMode: ({ usedAssets, assetsData }: {
 }) => boolean;
 export declare const aaveAnyGetCollSuppliedAssets: ({ usedAssets }: {
     usedAssets: AaveV3UsedAssets;
-}) => import("../../types").AaveV3UsedAsset[];
+}) => AaveV3UsedAsset[];
 export declare const aaveAnyGetSuppliableAssets: ({ usedAssets, eModeCategory, assetsData, selectedMarket, network, ...rest }: AaveHelperCommon) => {
     symbol: string;
     canBeCollateral: boolean;

package/esm/helpers/aaveHelpers/index.js

@@ -25,6 +25,7 @@ import { getNativeAssetFromWrapped, getWrappedNativeAssetFromUnwrapped } from '.
 import { aprToApy, calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos, } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
 import { borrowOperations } from '../../constants';
+import { LeverageType, } from '../../types/common';
 import { AaveLoanInfoV2ContractViem, AaveV3ViewContractViem } from '../../contracts';
 import { getViemProvider } from '../../services/viem';
 export const AAVE_V3_MARKETS = [AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi];
@@ -89,12 +90,22 @@ export const aaveAnyGetAggregatedPositionData = (_a) => {
     payload.liquidationPrice = '';
     if (leveragedType !== '') {
         let assetPrice = data.assetsData[leveragedAsset].price;
-        if (leveragedType === 'lsd-leverage') {
-            // Treat ETH like a stablecoin in a long stETH position
-            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
-            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = data.assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = data.assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();

package/esm/helpers/aaveV4Helpers/index.d.ts

@@ -0,0 +1,13 @@
+import { AaveV4AggregatedPositionData, AaveV4AssetsData, AaveV4ReserveAssetData, AaveV4UsedReserveAsset, AaveV4UsedReserveAssets } from '../../types';
+import { LeverageType, NetworkNumber } from '../../types/common';
+export declare const aaveV4GetCollateralFactor: (assetData: AaveV4ReserveAssetData, usedAssetData: AaveV4UsedReserveAsset, useUserCollateralFactor?: boolean) => number;
+export declare const isLeveragedPosAaveV4: (usedAssets: AaveV4UsedReserveAssets, dustLimit?: number) => {
+    leveragedType: LeverageType;
+    leveragedAsset: string;
+};
+export declare const aaveV4GetAggregatedPositionData: ({ usedAssets, assetsData, network, useUserCollateralFactor, }: {
+    usedAssets: AaveV4UsedReserveAssets;
+    assetsData: AaveV4AssetsData;
+    network: NetworkNumber;
+    useUserCollateralFactor?: boolean;
+}) => AaveV4AggregatedPositionData;

package/esm/helpers/aaveV4Helpers/index.js

@@ -0,0 +1,108 @@
+import Dec from 'decimal.js';
+import { calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS } from '../../moneymarket';
+import { LeverageType } from '../../types/common';
+export const aaveV4GetCollateralFactor = (assetData, usedAssetData, useUserCollateralFactor = false) => (useUserCollateralFactor ? usedAssetData.collateralFactor : assetData.collateralFactor);
+export const isLeveragedPosAaveV4 = (usedAssets, dustLimit = 5) => {
+    let borrowUnstable = 0;
+    let supplyStable = 0;
+    let borrowStable = 0;
+    let supplyUnstable = 0;
+    let longAsset = '';
+    let shortAsset = '';
+    Object.values(usedAssets).forEach(({ symbol, suppliedUsd, borrowedUsd, collateral, reserveId, }) => {
+        const spokeAsset = `${symbol}-${reserveId}`;
+        const isSupplied = (+suppliedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        const isBorrowed = (+borrowedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        if (isSupplied && STABLE_ASSETS.includes(symbol) && collateral)
+            supplyStable += 1;
+        if (isBorrowed && STABLE_ASSETS.includes(symbol))
+            borrowStable += 1;
+        if (isBorrowed && !STABLE_ASSETS.includes(symbol)) {
+            borrowUnstable += 1;
+            shortAsset = spokeAsset;
+        }
+        if (isSupplied && !STABLE_ASSETS.includes(symbol) && collateral) {
+            supplyUnstable += 1;
+            longAsset = spokeAsset;
+        }
+    });
+    const isLong = borrowStable > 0 && borrowUnstable === 0 && supplyUnstable === 1 && supplyStable === 0;
+    const isShort = supplyStable > 0 && supplyUnstable === 0 && borrowUnstable === 1 && borrowStable === 0;
+    const isVolatilePair = supplyUnstable === 1 && borrowUnstable === 1 && supplyStable === 0 && borrowStable === 0;
+    if (isLong) {
+        return {
+            leveragedType: LeverageType.Long,
+            leveragedAsset: longAsset,
+        };
+    }
+    if (isShort) {
+        return {
+            leveragedType: LeverageType.Short,
+            leveragedAsset: shortAsset,
+        };
+    }
+    if (isVolatilePair) {
+        return {
+            leveragedType: LeverageType.VolatilePair,
+            leveragedAsset: longAsset,
+        };
+    }
+    return {
+        leveragedType: LeverageType.None,
+        leveragedAsset: '',
+    };
+};
+export const aaveV4GetAggregatedPositionData = ({ usedAssets, assetsData, network, useUserCollateralFactor = false, }) => {
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd, reserveId }) => new Dec(suppliedUsd).mul(aaveV4GetCollateralFactor(assetsData[`${symbol}-${reserveId}`], usedAssets[`${symbol}-${reserveId}`], useUserCollateralFactor)));
+    payload.liquidationLimitUsd = payload.borrowLimitUsd;
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    payload.drawnUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ drawnUsd }) => drawnUsd);
+    payload.premiumUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ premiumUsd }) => premiumUsd);
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
+    payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    const { leveragedType, leveragedAsset } = isLeveragedPosAaveV4(usedAssets);
+    payload.leveragedType = leveragedType;
+    payload.leveragedAsset = leveragedAsset;
+    payload.liquidationPrice = '';
+    if (leveragedType !== '') {
+        const leveragedAssetData = assetsData[leveragedAsset];
+        let assetPrice = (leveragedAssetData === null || leveragedAssetData === void 0 ? void 0 : leveragedAssetData.price) || '0';
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[`${borrowedAsset.symbol}-${borrowedAsset.reserveId}`].price;
+            const leveragedAssetPrice = assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
+    payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    //   payload.healthRatio = new Dec(payload.liquidationLimitUsd).div(payload.borrowedUsd).toDP(4).toString();
+    payload.minHealthRatio = new Dec(payload.liquidationLimitUsd).div(payload.borrowLimitUsd).toDP(4).toString();
+    // TODO: Re-implement netApy calculation
+    //   const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({
+    //     usedAssets,
+    //     assetsData,
+    //     optionalData: { healthRatio: payload.healthRatio },
+    //   });
+    payload.netApy = '0';
+    payload.incentiveUsd = '0';
+    payload.totalInterestUsd = '0';
+    return payload;
+};

package/esm/helpers/compoundHelpers/index.js

@@ -25,7 +25,7 @@ import { addToArrayIf, getEthAmountForDecimals, handleWbtcLegacy, wethToEth, } f
 import { BLOCKS_IN_A_YEAR, borrowOperations, SECONDS_PER_YEAR } from '../../constants';
 import { aprToApy, calcLeverageLiqPrice, calculateBorrowingAssetLimit, getAssetsTotal, isLeveragedPos, } from '../../moneymarket';
 import { calculateNetApy, getStakingApy, STAKING_ASSETS } from '../../staking';
-import { IncentiveKind, NetworkNumber, } from '../../types/common';
+import { IncentiveKind, LeverageType, NetworkNumber, } from '../../types/common';
 import { CompoundLoanInfoContractViem, CompV3ViewContractViem } from '../../contracts';
 import { getViemProvider } from '../../services/viem';
 export const formatMarketData = (data, network, baseAssetPrice) => {
@@ -140,28 +140,25 @@ export const getCompoundV3AggregatedData = (_a) => {
     if (leveragedType !== '') {
         payload.leveragedAsset = leveragedAsset;
         let assetPrice = assetsData[leveragedAsset].price;
-        if (leveragedType === 'lsd-leverage') {
-            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toString();
-            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();
-    // TO DO: handle strategies
-    /* const subscribedStrategies = rest.compoundStrategies
-      ? compoundV3GetSubscribedStrategies({ selectedMarket, compoundStrategies: rest.compoundStrategies })
-      : []; */
-    // TODO possibly move to global helper, since every protocol has the same graphData?
-    // payload.ratioTooLow = false;
-    // payload.ratioTooHigh = false;
-    // TO DO: handle strategies
-    /* if (subscribedStrategies.length) {
-      subscribedStrategies.forEach(({ graphData }) => {
-        payload.ratioTooLow = parseFloat(payload.ratio) < parseFloat(graphData.minRatio);
-        payload.ratioTooHigh = graphData.boostEnabled && parseFloat(payload.ratio) > parseFloat(graphData.maxRatio);
-      });
-    } */
     return payload;
 };
 export const getApyAfterValuesEstimationCompoundV2 = (actions, provider) => __awaiter(void 0, void 0, void 0, function* () {

package/esm/helpers/eulerHelpers/index.d.ts

@@ -1,7 +1,7 @@
-import { EthAddress, EthereumProvider, NetworkNumber } from '../../types/common';
+import { EthAddress, EthereumProvider, LeverageType, NetworkNumber } from '../../types/common';
 import { EulerV2AggregatedPositionData, EulerV2AssetsData, EulerV2UsedAssets } from '../../types';
 export declare const isLeveragedPos: (usedAssets: EulerV2UsedAssets, dustLimit?: number) => {
-    leveragedType: string;
+    leveragedType: LeverageType;
     leveragedAsset: string;
     leveragedVault: string;
 };

package/esm/helpers/eulerHelpers/index.js

@@ -20,6 +20,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import Dec from 'decimal.js';
 import { assetAmountInWei } from '@defisaver/tokens';
+import { LeverageType, } from '../../types/common';
 import { calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS, } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
 import { EulerV2ViewContractViem } from '../../contracts';
@@ -53,31 +54,30 @@ export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
     });
     const isLong = borrowStable > 0 && borrowUnstable === 0 && supplyUnstable === 1 && supplyStable === 0;
     const isShort = supplyStable > 0 && supplyUnstable === 0 && borrowUnstable === 1 && borrowStable === 0;
-    // lsd -> liquid staking derivative
-    const isLsdLeveraged = supplyUnstable === 1 && borrowUnstable === 1 && shortAsset === 'ETH' && ['stETH', 'wstETH', 'cbETH', 'rETH'].includes(longAsset);
+    const isVolatilePair = supplyUnstable === 1 && borrowUnstable === 1 && supplyStable === 0 && borrowStable === 0;
     if (isLong) {
         return {
-            leveragedType: 'long',
+            leveragedType: LeverageType.Long,
             leveragedAsset: longAsset,
             leveragedVault: leverageAssetVault,
         };
     }
     if (isShort) {
         return {
-            leveragedType: 'short',
+            leveragedType: LeverageType.Short,
             leveragedAsset: shortAsset,
             leveragedVault: leverageAssetVault,
         };
     }
-    if (isLsdLeveraged) {
+    if (isVolatilePair) {
         return {
-            leveragedType: 'lsd-leverage',
+            leveragedType: LeverageType.VolatilePair,
             leveragedAsset: longAsset,
             leveragedVault: leverageAssetVault,
         };
     }
     return {
-        leveragedType: '',
+        leveragedType: LeverageType.None,
         leveragedAsset: '',
         leveragedVault: '',
     };
@@ -106,14 +106,22 @@ export const getEulerV2AggregatedData = (_a) => {
     if (leveragedType !== '') {
         payload.leveragedAsset = leveragedAsset;
         let assetPrice = assetsData[leveragedVault.toLowerCase()].price;
-        if (leveragedType === 'lsd-leverage') {
-            const ethAsset = Object.values(assetsData).find((asset) => ['WETH', 'ETH'].includes(asset.symbol));
-            if (ethAsset) {
-                payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedVault.toLowerCase()].price).div(ethAsset.price).toString();
-                assetPrice = new Dec(assetPrice).div(ethAsset.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[borrowedAsset.vaultAddress.toLowerCase()].price;
+            const leveragedAssetPrice = assetsData[leveragedVault.toLowerCase()].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
             }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();

package/esm/helpers/fluidHelpers/index.js

@@ -3,6 +3,7 @@ import { assetAmountInEth } from '@defisaver/tokens';
 import { FluidVaultType, } from '../../types';
 import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
+import { LeverageType } from '../../types/common';
 import { getEthAmountForDecimals } from '../../services/utils';
 const calculateNetApyDex = ({ marketData, suppliedUsd, borrowedUsd }) => {
     const { borrowRate, supplyRate, incentiveBorrowRate, incentiveSupplyRate, tradingBorrowRate, tradingSupplyRate, } = marketData;
@@ -49,12 +50,22 @@ export const getFluidAggregatedData = ({ usedAssets, assetsData, marketData, },
     if (leveragedType !== '') {
         payload.leveragedAsset = leveragedAsset;
         let assetPrice = assetsData[leveragedAsset].price;
-        if (leveragedType === 'lsd-leverage') {
-            // Treat ETH like a stablecoin in a long stETH position
-            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
-            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedUsd).div(payload.liquidationLimitUsd).mul(100).toString();

package/esm/helpers/index.d.ts

@@ -8,3 +8,4 @@ export * as llamaLendHelpers from './llamaLendHelpers';
 export * as liquityV2Helpers from './liquityV2Helpers';
 export * as eulerV2Helpers from './eulerHelpers';
 export * as fluidHelpers from './fluidHelpers';
+export * as aaveV4Helpers from './aaveV4Helpers';

package/esm/helpers/index.js

@@ -8,3 +8,4 @@ export * as llamaLendHelpers from './llamaLendHelpers';
 export * as liquityV2Helpers from './liquityV2Helpers';
 export * as eulerV2Helpers from './eulerHelpers';
 export * as fluidHelpers from './fluidHelpers';
+export * as aaveV4Helpers from './aaveV4Helpers';

package/esm/helpers/morphoBlueHelpers/index.js

@@ -11,7 +11,7 @@ import Dec from 'decimal.js';
 import { assetAmountInWei, getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
 import { aprToApy, calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos, } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
-import { NetworkNumber, } from '../../types/common';
+import { LeverageType, NetworkNumber, } from '../../types/common';
 import { borrowOperations, SECONDS_PER_YEAR, WAD } from '../../constants';
 import { MorphoBlueViewContractViem } from '../../contracts';
 import { compareAddresses, DEFAULT_TIMEOUT, wethToEth } from '../../services/utils';
@@ -45,12 +45,22 @@ export const getMorphoBlueAggregatedPositionData = ({ usedAssets, assetsData, ma
     if (leveragedType !== '') {
         payload.leveragedAsset = leveragedAsset;
         let assetPrice = assetsData[leveragedAsset].price;
-        if (leveragedType === 'lsd-leverage') {
-            // Treat ETH like a stablecoin in a long stETH position
-            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
-            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();

package/esm/helpers/sparkHelpers/index.d.ts

@@ -1,4 +1,4 @@
-import { SparkAggregatedPositionData, SparkAssetsData, SparkHelperCommon, SparkMarketData, SparkUsedAssets } from '../../types';
+import { SparkAggregatedPositionData, SparkAssetsData, SparkHelperCommon, SparkMarketData, SparkUsedAsset, SparkUsedAssets } from '../../types';
 import { EthereumProvider } from '../../types/common';
 export declare const sparkIsInIsolationMode: ({ usedAssets, assetsData }: {
     usedAssets: SparkUsedAssets;
@@ -6,7 +6,7 @@ export declare const sparkIsInIsolationMode: ({ usedAssets, assetsData }: {
 }) => boolean;
 export declare const sparkGetCollSuppliedAssets: ({ usedAssets }: {
     usedAssets: SparkUsedAssets;
-}) => import("../../types").SparkUsedAsset[];
+}) => SparkUsedAsset[];
 export declare const sparkGetSuppliableAssets: ({ usedAssets, eModeCategory, assetsData, selectedMarket, network, ...rest }: SparkHelperCommon) => {
     symbol: string;
     canBeCollateral: boolean;

package/esm/helpers/sparkHelpers/index.js

@@ -24,7 +24,7 @@ import { aprToApy, calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos, } from
 import { calculateNetApy } from '../../staking';
 import { ethToWeth, getNativeAssetFromWrapped, wethToEth } from '../../services/utils';
 import { SparkViewContractViem } from '../../contracts';
-import { NetworkNumber } from '../../types/common';
+import { LeverageType, NetworkNumber, } from '../../types/common';
 import { borrowOperations } from '../../constants';
 import { getViemProvider } from '../../services/viem';
 export const sparkIsInIsolationMode = ({ usedAssets, assetsData }) => Object.values(usedAssets).some(({ symbol, collateral }) => collateral && assetsData[symbol].isIsolated);
@@ -81,12 +81,22 @@ export const sparkGetAggregatedPositionData = (_a) => {
     if (leveragedType !== '') {
         payload.leveragedAsset = leveragedAsset;
         let assetPrice = data.assetsData[leveragedAsset].price; // TODO sparkPrice or price??
-        if (leveragedType === 'lsd-leverage') {
-            // Treat ETH like a stablecoin in a long stETH position
-            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
-            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = data.assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = data.assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
         }
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.minCollRatio = new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
     payload.collLiquidationRatio = new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();

package/esm/index.d.ts

@@ -1,5 +1,6 @@
 import './setup';
 import * as fluid from './fluid';
+import * as aaveV4 from './aaveV4';
 import * as aaveV3 from './aaveV3';
 import * as aaveV2 from './aaveV2';
 import * as compoundV3 from './compoundV3';
@@ -21,4 +22,4 @@ import * as portfolio from './portfolio';
 import * as claiming from './claiming';
 import * as savings from './savings';
 export * from './types';
-export { aaveV2, aaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, exchange, staking, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, portfolio, claiming, savings, };
+export { aaveV2, aaveV3, aaveV4, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, exchange, staking, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, portfolio, claiming, savings, };

package/esm/index.js

@@ -1,5 +1,6 @@
 import './setup';
 import * as fluid from './fluid';
+import * as aaveV4 from './aaveV4';
 import * as aaveV3 from './aaveV3';
 import * as aaveV2 from './aaveV2';
 import * as compoundV3 from './compoundV3';
@@ -21,4 +22,4 @@ import * as portfolio from './portfolio';
 import * as claiming from './claiming';
 import * as savings from './savings';
 export * from './types';
-export { aaveV2, aaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, exchange, staking, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, portfolio, claiming, savings, };
+export { aaveV2, aaveV3, aaveV4, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, exchange, staking, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, portfolio, claiming, savings, };

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

@@ -0,0 +1,16 @@
+import { AaveV4HubInfo, AaveV4HubsType, AaveV4SpokeInfo, AaveV4SpokesType, NetworkNumber } from '../../types';
+export declare const AAVE_V4_CORE_HUB: (networkId: NetworkNumber) => AaveV4HubInfo;
+export declare const AAVE_V4_YIELD_SEEKING_HUB: (networkId: NetworkNumber) => AaveV4HubInfo;
+export declare const AaveV4Hubs: (networkId: NetworkNumber) => {
+    readonly aave_v4_core_hub: AaveV4HubInfo;
+    readonly aave_v4_yield_seeking_hub: AaveV4HubInfo;
+};
+export declare const getAaveV4HubTypeInfo: (type: AaveV4HubsType, network?: NetworkNumber) => AaveV4HubInfo;
+export declare const getAaveV4HubByAddress: (networkId: NetworkNumber, address: string) => AaveV4HubInfo | undefined;
+export declare const AAVE_V4_CORE_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
+export declare const AAVE_V4_YIELD_SEEKING_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
+export declare const AaveV4Spokes: (networkId: NetworkNumber) => {
+    readonly aave_v4_core_spoke: AaveV4SpokeInfo;
+    readonly aave_v4_yield_seeking_spoke: AaveV4SpokeInfo;
+};
+export declare const getAaveV4SpokeTypeInfo: (type: AaveV4SpokesType, network?: NetworkNumber) => AaveV4SpokeInfo;

package/esm/markets/aaveV4/index.js

@@ -0,0 +1,47 @@
+import { AaveV4HubsType, AaveV4SpokesType, NetworkNumber, } from '../../types';
+// HUBS
+export const AAVE_V4_CORE_HUB = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Core Hub',
+    value: AaveV4HubsType.AaveV4CoreHub,
+    address: '0xaD905aD5EA5B98cD50AE40Cfe368344686a21366',
+});
+export const AAVE_V4_YIELD_SEEKING_HUB = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Yield Seeking Hub',
+    value: AaveV4HubsType.AaveV4YieldSeekingHub,
+    address: '0x86F37ba3b480c5fE22A7eb1ba2B2D49c94089FBB',
+});
+export const AaveV4Hubs = (networkId) => ({
+    [AaveV4HubsType.AaveV4CoreHub]: AAVE_V4_CORE_HUB(networkId),
+    [AaveV4HubsType.AaveV4YieldSeekingHub]: AAVE_V4_YIELD_SEEKING_HUB(networkId),
+});
+export const getAaveV4HubTypeInfo = (type, network) => (Object.assign({}, AaveV4Hubs(network !== null && network !== void 0 ? network : NetworkNumber.Eth))[type]);
+export const getAaveV4HubByAddress = (networkId, address) => Object.values(AaveV4Hubs(networkId)).find(hub => hub.address.toLowerCase() === address.toLowerCase());
+// SPOKES
+export const AAVE_V4_CORE_SPOKE = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Core Spoke',
+    value: AaveV4SpokesType.AaveV4CoreSpoke,
+    url: 'core',
+    address: '0xBa97c5E52cd5BC3D7950Ae70779F8FfE92d40CdC',
+    hubs: [
+        AAVE_V4_CORE_HUB(NetworkNumber.Eth).address,
+    ],
+});
+export const AAVE_V4_YIELD_SEEKING_SPOKE = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Yield Seeking Spoke',
+    value: AaveV4SpokesType.AaveV4YieldSeekingSpoke,
+    url: 'yield-seeking',
+    address: '0x2559e4e04f2ca7180e5f20c2872d22ec89601b56',
+    hubs: [
+        AAVE_V4_CORE_HUB(NetworkNumber.Eth).address,
+        AAVE_V4_YIELD_SEEKING_HUB(NetworkNumber.Eth).address,
+    ],
+});
+export const AaveV4Spokes = (networkId) => ({
+    [AaveV4SpokesType.AaveV4CoreSpoke]: AAVE_V4_CORE_SPOKE(networkId),
+    [AaveV4SpokesType.AaveV4YieldSeekingSpoke]: AAVE_V4_YIELD_SEEKING_SPOKE(networkId),
+});
+export const getAaveV4SpokeTypeInfo = (type, network) => (Object.assign({}, AaveV4Spokes(network !== null && network !== void 0 ? network : NetworkNumber.Eth))[type]);

package/esm/markets/index.d.ts

@@ -7,3 +7,4 @@ export { LlamaLendMarkets } from './llamaLend';
 export { LiquityV2Markets, findLiquityV2MarketByAddress } from './liquityV2';
 export { EulerV2Markets } from './euler';
 export { FluidMarkets, getFluidVersionsDataForNetwork, getFluidMarketInfoById, getFTokenAddress, getFluidMarketInfoByAddress, } from './fluid';
+export { AaveV4Spokes } from './aaveV4';

package/esm/markets/index.js

@@ -7,3 +7,4 @@ export { LlamaLendMarkets } from './llamaLend';
 export { LiquityV2Markets, findLiquityV2MarketByAddress } from './liquityV2';
 export { EulerV2Markets } from './euler';
 export { FluidMarkets, getFluidVersionsDataForNetwork, getFluidMarketInfoById, getFTokenAddress, getFluidMarketInfoByAddress, } from './fluid';
+export { AaveV4Spokes } from './aaveV4';

package/esm/moneymarket/moneymarketCommonService.d.ts

@@ -1,12 +1,12 @@
-import { MMUsedAssets } from '../types/common';
+import { LeverageType, MMUsedAssets } from '../types/common';
 export declare const getAssetsTotal: (assets: object, filter: any, transform: any) => any;
 export declare const calcLongLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
 export declare const calcShortLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
-export declare const calcLeverageLiqPrice: (leverageType: string, assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calcLeverageLiqPrice: (leverageType: LeverageType, assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
 export declare const calculateBorrowingAssetLimit: (assetBorrowedUsd: string, borrowLimitUsd: string) => string;
 export declare const STABLE_ASSETS: string[];
 export declare const isLeveragedPos: (usedAssets: MMUsedAssets, dustLimit?: number) => {
-    leveragedType: string;
+    leveragedType: LeverageType;
     leveragedAsset: string;
 };
 export declare const aprToApy: (interest: string | number, frequency?: number) => string;