@defisaver/positions-sdk 2.1.75 → 2.1.78-aave-v4-dev

package/cjs/types/aaveV4.d.ts

@@ -0,0 +1,153 @@
+import { EthAddress, IncentiveData, LeverageType, NetworkNumber } from './common';
+export declare enum AaveV4HubsType {
+    AaveV4CoreHub = "aave_v4_core_hub",
+    AaveV4PlusHub = "aave_v4_plus_hub",
+    AaveV4PrimeHub = "aave_v4_prime_hub"
+}
+export declare enum AaveV4SpokesType {
+    AaveV4BluechipSpoke = "aave_v4_bluechip_spoke",
+    AaveV4EthenaSpoke = "aave_v4_ethena_spoke",
+    AaveV4EtherfiSpoke = "aave_v4_etherfi_spoke",
+    AaveV4GoldSpoke = "aave_v4_gold_spoke",
+    AaveV4KelpSpoke = "aave_v4_kelp_spoke",
+    AaveV4LidoSpoke = "aave_v4_lido_spoke",
+    AaveV4MainSpoke = "aave_v4_main_spoke"
+}
+export interface AaveV4HubInfo {
+    chainIds: NetworkNumber[];
+    label: string;
+    value: AaveV4HubsType;
+    address: EthAddress;
+}
+export interface AaveV4HubAssetOnChainData {
+    assetId: number;
+    drawnRate: bigint;
+    liquidity: bigint;
+    liquidityFee: number;
+    swept: bigint;
+    totalDrawn: bigint;
+    totalDrawnShares: bigint;
+    totalPremiumShares: bigint;
+}
+export interface AaveV4HubOnChainData {
+    assets: Record<number, AaveV4HubAssetOnChainData>;
+}
+export interface AaveV4SpokeInfo {
+    chainIds: NetworkNumber[];
+    label: string;
+    value: AaveV4SpokesType;
+    url: string;
+    address: EthAddress;
+    hubs: EthAddress[];
+}
+export interface AaveV4SpokeData {
+    assetsData: AaveV4AssetsData;
+    oracle: EthAddress;
+    oracleDecimals: number;
+    address: EthAddress;
+}
+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;
+    spokeHalted: 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;
+    spokeHalted: boolean;
+    drawnRate: string;
+    supplyRate: string;
+    borrowRate: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
+    canBeBorrowed: boolean;
+    canBeSupplied: boolean;
+    canBeWithdrawn: boolean;
+    canBePayBacked: boolean;
+    utilization: string;
+}
+export type AaveV4AssetsData = Record<string, AaveV4ReserveAssetData>;
+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;
+    riskPremiumBps: number;
+}

package/cjs/types/aaveV4.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AaveV4SpokesType = exports.AaveV4HubsType = void 0;
+var AaveV4HubsType;
+(function (AaveV4HubsType) {
+    AaveV4HubsType["AaveV4CoreHub"] = "aave_v4_core_hub";
+    AaveV4HubsType["AaveV4PlusHub"] = "aave_v4_plus_hub";
+    AaveV4HubsType["AaveV4PrimeHub"] = "aave_v4_prime_hub";
+})(AaveV4HubsType || (exports.AaveV4HubsType = AaveV4HubsType = {}));
+var AaveV4SpokesType;
+(function (AaveV4SpokesType) {
+    AaveV4SpokesType["AaveV4BluechipSpoke"] = "aave_v4_bluechip_spoke";
+    AaveV4SpokesType["AaveV4EthenaSpoke"] = "aave_v4_ethena_spoke";
+    AaveV4SpokesType["AaveV4EtherfiSpoke"] = "aave_v4_etherfi_spoke";
+    AaveV4SpokesType["AaveV4GoldSpoke"] = "aave_v4_gold_spoke";
+    AaveV4SpokesType["AaveV4KelpSpoke"] = "aave_v4_kelp_spoke";
+    AaveV4SpokesType["AaveV4LidoSpoke"] = "aave_v4_lido_spoke";
+    AaveV4SpokesType["AaveV4MainSpoke"] = "aave_v4_main_spoke";
+})(AaveV4SpokesType || (exports.AaveV4SpokesType = AaveV4SpokesType = {}));

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/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/esm/aaveV3/merkl.js

@@ -35,7 +35,7 @@ export const formatAaveAsset = (_symbol) => {
 };
 export const getMerkleCampaigns = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const res = yield fetch('https://api.merkl.xyz/v4/opportunities?mainProtocolId=aave', {
+        const res = yield fetch('https://api-merkl.angle.money/v4/opportunities?mainProtocolId=aave', {
             signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
         });
         if (!res.ok)

package/esm/aaveV4/index.d.ts

@@ -0,0 +1,7 @@
+import { Client } from 'viem';
+import { AaveV4AccountData, AaveV4SpokeData, AaveV4SpokeInfo, EthAddress, EthereumProvider, NetworkNumber } from '../types';
+export * as lend from './lend';
+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,255 @@
+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';
+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';
+import { aprToApy } from '../moneymarket';
+export * as lend from './lend';
+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,
+                liquidity: assetOnChainData.liquidity,
+                liquidityFee: assetOnChainData.liquidityFee,
+                swept: assetOnChainData.swept,
+                totalDrawn: assetOnChainData.totalDrawn,
+                totalDrawnShares: assetOnChainData.totalDrawnShares,
+                totalPremiumShares: assetOnChainData.totalPremiumShares,
+            };
+            return acc;
+        }, {}),
+    };
+});
+// TODO AaveV4: Will be used for after values, onchain data is available when fetching position data
+const calcUserRiskPremiumBps = (usedAssets, assetsData) => {
+    const collaterals = [];
+    const debts = [];
+    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();
+};
+const formatReserveAsset = (reserveAsset, hubAsset, reserveId, oracleDecimals, network) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    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.`,
+            });
+        }
+    }
+    const totalSuppliedRaw = (_a = reserveAsset.totalSupplied) !== null && _a !== void 0 ? _a : 0;
+    const totalDrawnRaw = (_b = reserveAsset.totalDrawn) !== null && _b !== void 0 ? _b : 0;
+    const totalPremiumRaw = (_c = reserveAsset.totalPremium) !== null && _c !== void 0 ? _c : 0;
+    const totalDebtRaw = (_d = reserveAsset.totalDebt) !== null && _d !== void 0 ? _d : 0;
+    const supplyCapRaw = (_e = reserveAsset.supplyCap) !== null && _e !== void 0 ? _e : 0;
+    const borrowCapRaw = (_f = reserveAsset.borrowCap) !== null && _f !== void 0 ? _f : 0;
+    const totalSuppliedDec = new Dec(totalSuppliedRaw.toString());
+    const totalDrawnDec = new Dec(totalDrawnRaw.toString());
+    const utilization = totalSuppliedDec.isZero() ? '0' : totalDrawnDec.times(100).div(totalSuppliedDec).toString();
+    /** @DEV Hub related calculations */
+    const drawnRate = new Dec(hubAsset.drawnRate.toString()).div(new Dec(10).pow(27));
+    const borrowApr = drawnRate.mul(100);
+    const totalDrawn = new Dec(hubAsset.totalDrawn.toString());
+    const liquidity = new Dec(hubAsset.liquidity.toString());
+    const swept = new Dec(hubAsset.swept.toString());
+    const hubUtilizationDenominator = totalDrawn.add(swept).add(liquidity);
+    const hubUtilization = hubUtilizationDenominator.isZero() ? new Dec(0) : totalDrawn.div(hubUtilizationDenominator);
+    const liquidityFee = new Dec(hubAsset.liquidityFee.toString()).div(new Dec(10).pow(4));
+    const totalDrawnShares = new Dec(hubAsset.totalDrawnShares.toString());
+    const totalPremiumShares = new Dec(hubAsset.totalPremiumShares.toString());
+    // TODO JK@JK premiumMultiplier should be added to supplyApr calculation (.mul(premiumMultiplier)
+    // TODO JKJ@JK when we confirm that this is the right way to calculate it
+    const premiumMultiplier = totalDrawnShares.isZero() ? new Dec(1) : totalDrawnShares.add(totalPremiumShares).div(totalDrawnShares);
+    const supplyApr = borrowApr.mul(hubUtilization).mul(new Dec(1).minus(liquidityFee));
+    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(totalSuppliedRaw.toString(), symbol),
+        totalDrawn: assetAmountInEth(totalDrawnRaw.toString(), symbol),
+        totalPremium: assetAmountInEth(totalPremiumRaw.toString(), symbol),
+        totalDebt: assetAmountInEth(totalDebtRaw.toString(), symbol),
+        supplyCap: assetAmountInEth(supplyCapRaw.toString(), symbol),
+        borrowCap: assetAmountInEth(borrowCapRaw.toString(), symbol),
+        spokeActive: reserveAsset.spokeActive,
+        spokeHalted: reserveAsset.spokeHalted,
+        drawnRate: drawnRate.toString(),
+        borrowRate: aprToApy(borrowApr.toString()),
+        supplyRate: aprToApy(supplyApr.toString()),
+        supplyIncentives,
+        borrowIncentives,
+        canBeBorrowed: reserveAsset.spokeActive && !reserveAsset.spokeHalted && !reserveAsset.paused && !reserveAsset.frozen,
+        canBeSupplied: reserveAsset.spokeActive && !reserveAsset.spokeHalted && !reserveAsset.paused && !reserveAsset.frozen,
+        canBeWithdrawn: reserveAsset.spokeActive && !reserveAsset.spokeHalted && !reserveAsset.paused,
+        canBePayBacked: reserveAsset.spokeActive && !reserveAsset.spokeHalted && !reserveAsset.paused,
+        utilization,
+    });
+});
+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;
+        }, {});
+        const aggregated = aaveV4GetAggregatedPositionData({
+            usedAssets,
+            assetsData: spokeData.assetsData,
+            network,
+            useUserCollateralFactor: true,
+        });
+        const riskPremiumBps = calcUserRiskPremiumBps(usedAssets, spokeData.assetsData);
+        return Object.assign(Object.assign({}, aggregated), { usedAssets,
+            healthFactor,
+            riskPremiumBps });
+    });
+}
+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/aaveV4/lend.d.ts

@@ -0,0 +1,45 @@
+import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+export interface AaveV4TokenizationSpokeData {
+    underlyingAsset: EthAddress;
+    assetId: string;
+    decimals: number;
+    spoke: EthAddress;
+    spokeActive: boolean;
+    spokeHalted: boolean;
+    spokeDepositCap: string;
+    spokeTotalAssets: string;
+    spokeTotalShares: string;
+    hub: EthAddress;
+    hubLiquidity: string;
+    hubDrawnRate: string;
+    convertToShares: string;
+    convertToAssets: string;
+    user: EthAddress;
+    userSuppliedAssets: string;
+    userSuppliedShares: string;
+}
+export declare const AAVE_V4_TOKENIZED_SPOKES: Record<string, EthAddress>;
+export declare const AAVE_V4_TOKENIZED_SPOKE_ADDRESSES: Partial<Record<NetworkNumber, EthAddress[]>>;
+export type AaveV4TokenizedHubKey = 'CORE' | 'PLUS' | 'PRIME';
+export declare const aaveV4GetTokenizedHubKey: (hubNameOrKey?: string | null) => AaveV4TokenizedHubKey | null;
+export declare const aaveV4GetTokenizedVaultKey: (symbol: string, hubNameOrKey?: string | null) => string | null;
+export declare const aaveV4GetTokenizedVaultAddress: (network: NetworkNumber, symbol: string, hubNameOrKey?: string | null) => EthAddress | undefined;
+/** Parsed tokenization spoke data with human-readable supplied amounts for display */
+export interface AaveV4TokenizationSpokeDataParsed {
+    vaultAddress: EthAddress;
+    key: string | null;
+    symbol: string;
+    hubKey: string;
+    userSuppliedAssetsEth: string;
+    userSuppliedSharesEth: string;
+    userSuppliedAssets: string;
+    userSuppliedShares: string;
+    underlyingAsset: EthAddress;
+    spoke: EthAddress;
+    decimals: number;
+}
+/**
+ * Fetches tokenization vault data for the given user via getTokenizationSpokesData.
+ * Returns parsed data including userSuppliedAssets in human-readable form for each vault.
+ */
+export declare function getAaveV4TokenizationSpokesData(provider: EthereumProvider, network: NetworkNumber, userAddress: EthAddress): Promise<AaveV4TokenizationSpokeDataParsed[]>;

package/esm/aaveV4/lend.js

@@ -0,0 +1,134 @@
+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 { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { AaveV4ViewContractViem } from '../contracts';
+import { getViemProvider } from '../services/viem';
+import { wethToEth } from '../services/utils';
+import { NetworkNumber, } from '../types/common';
+export const AAVE_V4_TOKENIZED_SPOKES = {
+    AAVE_CORE: '0x08309234884cF7E015b07Bf22569017Aa035cdeF',
+    EURC_CORE: '0x73596dED4B2Eb0aC85e477b3c8dB56FC427E6774',
+    GHO_CORE: '0xf7E1f1b43922527e5054bD77E7f863Cf182b194D',
+    GHO_PRIME: '0xeF1cAd5c6a2C9cb83c952b4B96bbD35b3F61F18f',
+    LBTC_CORE: '0x8f4D423590F22833131e3493bf67A27213398f8e',
+    LINK_CORE: '0xBE1197750b423e30137E97d9183065d33E903BE6',
+    PT_USDe_PLUS: '0x8cA27Ab284F2aA2BcF33D9129e11c101aD2d16de',
+    PT_sUSDe_PLUS: '0xb8A464EC56071a98c854f30fE19CfeCc41FA6233',
+    PYUSD_CORE: '0x203FB463087005698d50768FcA837047f738632d',
+    RLUSD_CORE: '0xa9afdd0c54fb153CaE39cE86E49626B5e9d15513',
+    USDC_CORE: '0xa2e476f4cbB06C7bFA8Ad51bCcbF198cd32CfD35',
+    USDC_PLUS: '0x320Bec4fB7a25e64c003A007D0AeF7AB3D6C30d7',
+    USDC_PRIME: '0x0A0507F7A1129892b5cf74b8B4e911442c466b87',
+    USDG_CORE: '0x87c224256f09a014C1BC3e9FbB094C3AdD8fBaCC',
+    USDT_CORE: '0x3f12BD5999b9172550893FF52691c980676f9E73',
+    USDT_PLUS: '0xa4E74a78bED2d3ab8971e8AB26fb39f26DD8eEd9',
+    USDT_PRIME: '0xF565fB55bc96d65561887898bfeb25C1dE7e06d2',
+    USDe_PLUS: '0xA0d346ab2699B689AC67aba5174164A84206BB73',
+    WBTC_CORE: '0x837Ab872A665e0CF467d41cF56a054031b4A38bc',
+    WBTC_PRIME: '0xeae98b8a1798738182B2123DF1eB93d97BD29F34',
+    WETH_CORE: '0x3961a75099E986F59a1a31c6f945061641dFD2b2',
+    WETH_PRIME: '0xa411826a6ef5d289c0FAa7d5B45FE8aAB52257F6',
+    XAUt_CORE: '0x470341bC0e2B833C54D0120642713BdF762A494F',
+    cbBTC_CORE: '0xe8D5E595d5b6b5EFf84B7064765fd0e8DfD214C9',
+    cbBTC_PRIME: '0x0E986545150DcDDe46Ea9df355D0fD2af33bd75D',
+    frxUSD_CORE: '0x00C8A6a42947Cc4E7B6f27963Cab0143ccaaD2B5',
+    frxUSD_PLUS: '0xCAB288d37CAb5a9db7b503F086455276Dcde61F1',
+    rsETH_CORE: '0x6eEce89caE2163584bA7Ff9743861B9633c245E0',
+    sUSDe_PLUS: '0xdf47fc43c88B06edC47753b7d647ff18037D2F3d',
+    weETH_CORE: '0xB67F20bFF413C8E5d633B54BD28899c4c9e33ed0',
+    wstETH_CORE: '0x474602394d0B02F43AC3D7C8c5cFc0814b03fd40',
+    wstETH_PRIME: '0xAcCdAb49ECB9A801CfF62a92fc80D52339b33770',
+};
+export const AAVE_V4_TOKENIZED_SPOKE_ADDRESSES = {
+    [NetworkNumber.Eth]: Object.values(AAVE_V4_TOKENIZED_SPOKES),
+};
+export const aaveV4GetTokenizedHubKey = (hubNameOrKey) => {
+    if (!hubNameOrKey)
+        return null;
+    const normalized = hubNameOrKey.trim().toUpperCase();
+    // TODO AaveV4 Maybe turn into constants
+    if (normalized === 'CORE' || normalized === 'CORE HUB')
+        return 'CORE';
+    if (normalized === 'PLUS' || normalized === 'PLUS HUB')
+        return 'PLUS';
+    if (normalized === 'PRIME' || normalized === 'PRIME HUB')
+        return 'PRIME';
+    if (normalized.includes('CORE'))
+        return 'CORE';
+    if (normalized.includes('PLUS'))
+        return 'PLUS';
+    if (normalized.includes('PRIME'))
+        return 'PRIME';
+    return null;
+};
+export const aaveV4GetTokenizedVaultKey = (symbol, hubNameOrKey) => {
+    if (!symbol)
+        return null;
+    const hubKey = aaveV4GetTokenizedHubKey(hubNameOrKey);
+    if (!hubKey)
+        return null;
+    const normalizedSymbol = symbol.trim().replace(/-/g, '_');
+    return `${normalizedSymbol}_${hubKey}`;
+};
+export const aaveV4GetTokenizedVaultAddress = (network, symbol, hubNameOrKey) => {
+    if (network !== NetworkNumber.Eth)
+        return undefined;
+    const key = aaveV4GetTokenizedVaultKey(symbol, hubNameOrKey);
+    if (!key)
+        return undefined;
+    return AAVE_V4_TOKENIZED_SPOKES[key];
+};
+const AAVE_V4_TOKENIZED_SPOKE_ADDRESS_TO_KEY = Object.entries(AAVE_V4_TOKENIZED_SPOKES).reduce((acc, [k, v]) => {
+    acc[v.toLowerCase()] = k;
+    return acc;
+}, {});
+/**
+ * Fetches tokenization vault data for the given user via getTokenizationSpokesData.
+ * Returns parsed data including userSuppliedAssets in human-readable form for each vault.
+ */
+export function getAaveV4TokenizationSpokesData(provider, network, userAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const spokes = (_a = AAVE_V4_TOKENIZED_SPOKE_ADDRESSES[network]) !== null && _a !== void 0 ? _a : [];
+        if (spokes.length === 0)
+            return [];
+        const client = getViemProvider(provider, network);
+        const viewContract = AaveV4ViewContractViem(client, network);
+        const raw = yield viewContract.read.getTokenizationSpokesData([spokes, userAddress]);
+        return raw.map((r, i) => {
+            var _a, _b, _c, _d, _e;
+            const vaultAddress = spokes[i];
+            const key = (_a = AAVE_V4_TOKENIZED_SPOKE_ADDRESS_TO_KEY[vaultAddress.toLowerCase()]) !== null && _a !== void 0 ? _a : null;
+            const symbol = wethToEth(getAssetInfoByAddress(r.underlyingAsset, network).symbol);
+            if (symbol === '?') { // unsupported asset
+                return null;
+            }
+            const hubKey = key ? (_b = key.split('_').pop()) !== null && _b !== void 0 ? _b : '' : '';
+            const decimals = Number((_c = r.decimals) !== null && _c !== void 0 ? _c : 18);
+            const userSuppliedAssetsRaw = (_d = r.userSuppliedAssets) !== null && _d !== void 0 ? _d : 0;
+            const userSuppliedSharesRaw = (_e = r.userSuppliedShares) !== null && _e !== void 0 ? _e : 0;
+            const userSuppliedAssetsEth = assetAmountInEth(userSuppliedAssetsRaw.toString(), symbol);
+            const userSuppliedSharesEth = assetAmountInEth(userSuppliedSharesRaw.toString(), symbol);
+            return {
+                vaultAddress,
+                key,
+                symbol,
+                hubKey,
+                userSuppliedAssetsEth,
+                userSuppliedSharesEth,
+                userSuppliedAssets: userSuppliedAssetsRaw.toString(),
+                userSuppliedShares: userSuppliedSharesRaw.toString(),
+                underlyingAsset: r.underlyingAsset,
+                spoke: r.spoke,
+                decimals,
+            };
+        }).filter(item => item != null);
+    });
+}

package/esm/claiming/aaveV3.js

@@ -92,7 +92,7 @@ export function getMeritUnclaimedRewards(account_1, network_1) {
     return __awaiter(this, arguments, void 0, function* (account, network, acceptMorpho = true) {
         let data;
         try {
-            const res = yield fetch(`https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${network}`, { signal: AbortSignal.timeout(3000) });
+            const res = yield fetch(`https://api-merkl.angle.money/v4/users/${account}/rewards?chainId=${network}`, { signal: AbortSignal.timeout(3000) });
             data = yield res.json();
         }
         catch (error) {