import Dec from 'decimal.js'; import { assetAmountInWei } from '@defisaver/tokens'; import { Client } from 'viem'; import { aprToApy, calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS, } from '../../moneymarket'; import { calculateInterestEarned } from '../../staking'; import { AaveV4AggregatedPositionData, AaveV4AssetsData, AaveV4MerklIncentive, AaveV4ReserveAssetData, AaveV4SpokeInfo, AaveV4UsedReserveAsset, AaveV4UsedReserveAssets, EthereumProvider, IncentiveData, IncentiveSide, LeverageType, NetworkNumber, } from '../../types'; import { borrowOperations } from '../../constants'; import { AaveV4ViewContractViem } from '../../contracts'; import { getViemProvider } from '../../services/viem'; export const calcUserRiskPremiumBps = (usedAssets: AaveV4UsedReserveAssets, assetsData: AaveV4AssetsData): number => { type CollateralInfo = { riskBps: number; valueUsd: Dec }; type DebtInfo = { valueUsd: Dec }; const collaterals: CollateralInfo[] = []; const debts: DebtInfo[] = []; Object.entries(usedAssets).forEach(([identifier, asset]) => { const reserveData = assetsData[identifier]; if (!reserveData) return; const borrowedUsdDec = new Dec(asset.borrowedUsd || '0'); if (asset.isBorrowed && borrowedUsdDec.gt(0)) { debts.push({ valueUsd: borrowedUsdDec }); } const suppliedUsdDec = new Dec(asset.suppliedUsd || '0'); const isActiveCollateral = asset.collateral && asset.isSupplied && asset.collateralFactor > 0 && suppliedUsdDec.gt(0); if (isActiveCollateral) { // collateralRisk is stored as a fraction (e.g. 0.25), convert back to bps const riskBps = new Dec(reserveData.collateralRisk).mul(10000).toNumber(); collaterals.push({ riskBps, valueUsd: suppliedUsdDec, }); } }); const totalDebtUsd = debts.reduce((sum, d) => sum.add(d.valueUsd), new Dec(0)); if (totalDebtUsd.lte(0)) { return 0; } // sort by risk ASC, value DESC collaterals.sort((a, b) => { if (a.riskBps !== b.riskBps) return a.riskBps - b.riskBps; return b.valueUsd.comparedTo(a.valueUsd); }); let debtLeftToCover = totalDebtUsd; let numerator = new Dec(0); // sum(coveredUsd * riskBps) let coveredDebt = new Dec(0); // sum(coveredUsd) collaterals.forEach(({ riskBps, valueUsd }) => { if (debtLeftToCover.lte(0)) return; const coveredUsd = Dec.min(valueUsd, debtLeftToCover); numerator = numerator.add(coveredUsd.mul(riskBps)); coveredDebt = coveredDebt.add(coveredUsd); debtLeftToCover = debtLeftToCover.sub(coveredUsd); }); if (coveredDebt.lte(0)) { return 0; } const riskPremiumBps = numerator.div(coveredDebt); return riskPremiumBps.toNumber(); }; /** * `spokeXIncentives`/`hubXIncentives` are each the intrinsic `base` list with the Merkl rewards * of that scope appended (see attachAaveV4MerklIncentives). Merkl publishes a hub reward stream at both * scopes — the hub (parent) campaign plus a child campaign per covered spoke (e.g. USDC borrowed * from the Prime Hub via the Bluechip Spoke) — so a child must never be summed with its parent: * the more specific spoke listing wins. A hub reward the spoke reward is not a child of comes from * a distinct campaign, and both genuinely accrue, so they are shown together — which is also what * every per-asset APY badge (and Aave's own UI) shows. */ const mergeScopedIncentives = (base: IncentiveData[] = [], spokeScoped?: IncentiveData[], hubScoped?: IncentiveData[]): IncentiveData[] => { const spokeExtras: AaveV4MerklIncentive[] = spokeScoped ? spokeScoped.slice(base.length) : []; const hubExtras: AaveV4MerklIncentive[] = hubScoped ? hubScoped.slice(base.length) : []; const parentIds = new Set(); spokeExtras.forEach((extra) => extra.parentCampaignIds?.forEach((id) => parentIds.add(id))); const distinctHubExtras = hubExtras.filter((extra) => { // without campaign identity the parent/child relation is unknowable — fail closed to spoke-wins if (!extra.campaignIds?.length) return !spokeExtras.length; return !extra.campaignIds.some((id) => parentIds.has(id)); }); return [...base, ...spokeExtras, ...distinctHubExtras]; }; /** * The incentives that actually accrue to a position on this reserve for the given side: the * intrinsic (staking) incentives plus the applicable Merkl rewards. Display surfaces should * use this rather than picking a scoped list directly, so badges always match the net APY math. */ export const getAaveV4ApplicableIncentives = (assetData: AaveV4ReserveAssetData, side: IncentiveSide): IncentiveData[] => (side === IncentiveSide.Supply ? mergeScopedIncentives(assetData.supplyIncentives, assetData.spokeSupplyIncentives, assetData.hubSupplyIncentives) : mergeScopedIncentives(assetData.borrowIncentives, assetData.spokeBorrowIncentives, assetData.hubBorrowIncentives)); export const calculateNetApyAaveV4 = ({ usedAssets, assetsData, }: { usedAssets: AaveV4UsedReserveAssets, assetsData: AaveV4AssetsData, }) => { const riskPremiumBps = calcUserRiskPremiumBps(usedAssets, assetsData); const riskPremiumFraction = new Dec(riskPremiumBps).div(10000); const sumValues = Object.entries(usedAssets).reduce((_acc, [identifier, usedAsset]) => { const acc = { ..._acc }; const assetData = assetsData[identifier]; if (!assetData) return acc; if (usedAsset.isSupplied) { const amount = usedAsset.suppliedUsd; acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString(); const supplyInterest = calculateInterestEarned(amount, assetData.supplyRate, 'year', true); acc.supplyInterest = new Dec(acc.supplyInterest).add(supplyInterest.toString()).toString(); const supplyIncentives = getAaveV4ApplicableIncentives(assetData, IncentiveSide.Supply); for (const supplyIncentive of supplyIncentives) { const incentiveInterest = calculateInterestEarned(amount, supplyIncentive.apy, 'year', true); acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString(); } } if (usedAsset.isBorrowed) { const amount = usedAsset.borrowedUsd; acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString(); // User borrow rate = baseRate * (1 + riskPremiumFraction) const drawnRate = new Dec(assetData.drawnRate); const baseBorrowApr = drawnRate.mul(100); const userBorrowApr = baseBorrowApr.mul(new Dec(1).add(riskPremiumFraction)); const userBorrowRate = aprToApy(userBorrowApr.toString()); const borrowInterest = calculateInterestEarned(amount, userBorrowRate, 'year', true); acc.borrowInterest = new Dec(acc.borrowInterest).sub(borrowInterest.toString()).toString(); const borrowIncentives = getAaveV4ApplicableIncentives(assetData, IncentiveSide.Borrow); for (const borrowIncentive of borrowIncentives) { const incentiveInterest = calculateInterestEarned(amount, borrowIncentive.apy, 'year', true); acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString(); } } return acc; }, { borrowInterest: '0', supplyInterest: '0', incentiveUsd: '0', borrowedUsd: '0', suppliedUsd: '0', }); const { borrowedUsd, suppliedUsd, borrowInterest, supplyInterest, incentiveUsd, } = sumValues; const totalInterestUsd = new Dec(borrowInterest).add(supplyInterest).add(incentiveUsd).toString(); const balance = new Dec(suppliedUsd).sub(borrowedUsd); const netApy = balance.isZero() ? '0' : new Dec(totalInterestUsd).div(balance).times(100).toString(); return { netApy, totalInterestUsd, incentiveUsd }; }; export const aaveV4GetCollateralFactor = (assetData: AaveV4ReserveAssetData, usedAssetData: AaveV4UsedReserveAsset, useUserCollateralFactor: boolean = false): number => (useUserCollateralFactor ? usedAssetData.collateralFactor : assetData.collateralFactor); export const isLeveragedPosAaveV4 = (usedAssets: AaveV4UsedReserveAssets, 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 dustLimit; // ignore dust like 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, }: { usedAssets: AaveV4UsedReserveAssets, assetsData: AaveV4AssetsData, network: NetworkNumber, useUserCollateralFactor?: boolean, }): AaveV4AggregatedPositionData => { const payload = {} as AaveV4AggregatedPositionData; payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }: { isSupplied: boolean }) => isSupplied, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd); payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: string }) => isSupplied && collateral, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd); payload.borrowLimitUsd = getAssetsTotal( usedAssets, ({ isSupplied, collateral }: { isSupplied: boolean, collateral: string }) => isSupplied && collateral, ({ symbol, suppliedUsd, reserveId }: { symbol: string, suppliedUsd: string, reserveId: number }) => new Dec(suppliedUsd).mul(aaveV4GetCollateralFactor(assetsData[`${symbol}-${reserveId}`], usedAssets[`${symbol}-${reserveId}`], useUserCollateralFactor)), ); payload.liquidationLimitUsd = payload.borrowLimitUsd; payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd); payload.drawnUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ drawnUsd }: { drawnUsd: string }) => drawnUsd); payload.premiumUsd = getAssetsTotal(usedAssets, ({ isBorrowed }: { isBorrowed: boolean }) => isBorrowed, ({ premiumUsd }: { premiumUsd: string }) => 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.minRatio = '100'; payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0'; payload.safetyRatio = payload.ratio; 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?.price || '0'; if (leveragedType === LeverageType.VolatilePair) { const borrowedAsset = (Object.values(usedAssets) as AaveV4UsedReserveAsset[]).find(({ borrowedUsd }: { borrowedUsd: string }) => +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(); const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApyAaveV4({ usedAssets, assetsData }); payload.netApy = netApy; payload.incentiveUsd = incentiveUsd; payload.totalInterestUsd = totalInterestUsd; return payload; }; const getAaveV4ApyAfterValuesEstimationInner = async (selectedSpoke: AaveV4SpokeInfo, assetsData: AaveV4AssetsData, actions: { action: string, amount: string, asset: string }[], client: Client, network: NetworkNumber) => { const params = actions.map(({ action, asset, amount }) => { const isDebtAsset = borrowOperations.includes(action); const assetData = assetsData[asset]; const amountInWei = assetAmountInWei(amount, assetData.symbol); let liquidityAdded; let liquidityTaken; if (isDebtAsset) { liquidityAdded = action === 'payback' ? amountInWei : '0'; liquidityTaken = action === 'borrow' ? amountInWei : '0'; } else { liquidityAdded = action === 'collateral' ? amountInWei : '0'; liquidityTaken = action === 'withdraw' ? amountInWei : '0'; } return { reserveId: BigInt(assetData.reserveId), liquidityAdded: BigInt(liquidityAdded), liquidityTaken: BigInt(liquidityTaken), isDebtAsset, }; }); const viewContract = AaveV4ViewContractViem(client, network); const data = await viewContract.read.getApyAfterValuesEstimation([selectedSpoke.address, params]); const rates: { [key: string]: { supplyRate: string, borrowRate: string, drawnRate: string } } = {}; data.forEach((item: any) => { const { hubDrawnRateEstimation, hubTotalDrawnEstimation, hubTotalLiquidityEstimation, hubSwept, reserveId, } = item; const drawnRate = new Dec(hubDrawnRateEstimation.toString()).div(new Dec(10).pow(27)); const borrowApr = drawnRate.mul(100); const assetData = Object.values(assetsData).find(({ reserveId: rId }) => rId === Number(reserveId)); const totalDrawn = new Dec(hubTotalDrawnEstimation.toString()); const swept = new Dec(hubSwept.toString()); const hubUtilizationDenominator = totalDrawn.add(swept).add(hubTotalLiquidityEstimation.toString()); const hubUtilization = hubUtilizationDenominator.isZero() ? new Dec(0) : totalDrawn.div(hubUtilizationDenominator); const supplyApr = borrowApr.mul(hubUtilization).mul(assetData?.premiumMultiplier || '1').mul(new Dec(1).minus(assetData?.liquidityFee || '0')); rates[`${assetData?.symbol}-${assetData?.reserveId}`] = { borrowRate: aprToApy(borrowApr.toString()), supplyRate: aprToApy(supplyApr.toString()), drawnRate: drawnRate.toString(), }; }); return rates; }; export const getAaveV4ApyAfterValuesEstimation = async (selectedSpoke: AaveV4SpokeInfo, assetsData: AaveV4AssetsData, actions: { action: string, amount: string, asset: string }[], provider: EthereumProvider, network: NetworkNumber) => getAaveV4ApyAfterValuesEstimationInner(selectedSpoke, assetsData, actions, getViemProvider(provider, network), network);