@defisaver/positions-sdk 2.1.1-dev.0 → 2.1.2

package/esm/contracts.js

@@ -80,3 +80,12 @@ export const LiquityActivePoolContractViem = createViemContractFromConfigFunc('L
 export const LiquityV2ViewContractViem = createViemContractFromConfigFunc('LiquityV2View');
 export const LiquityV2LegacyViewContractViem = createViemContractFromConfigFunc('LiquityV2LegacyView');
 export const FluidViewContractViem = createViemContractFromConfigFunc('FluidView');
+export const AaveIncentivesControllerViem = createViemContractFromConfigFunc('AaveIncentivesController');
+export const AaveUmbrellaViewViem = createViemContractFromConfigFunc('AaveUmbrellaView');
+export const LiquityLQTYStakingViem = createViemContractFromConfigFunc('LiquityLQTYStaking');
+export const LiquityStabilityPoolViem = createViemContractFromConfigFunc('LiquityStabilityPool');
+export const UUPSViem = createViemContractFromConfigFunc('UUPS');
+export const SparkRewardsControllerViem = createViemContractFromConfigFunc('SparkRewardsController');
+export const AaveRewardsControllerViem = createViemContractFromConfigFunc('AaveRewardsController');
+export const LiquityV2sBoldVaultViem = createViemContractFromConfigFunc('LiquityV2sBoldVault');
+export const StkAAVEViem = createViemContractFromConfigFunc('StkAAVE');

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

@@ -41,3 +41,7 @@ export declare const getApyAfterValuesEstimation: (selectedMarket: AaveMarketInf
         borrowRate: string;
     };
 }>;
+/**
+ * won't cover all cases
+ */
+export declare const getAaveUnderlyingSymbol: (_symbol?: string) => any;

package/esm/helpers/aaveHelpers/index.js

@@ -140,3 +140,18 @@ const getApyAfterValuesEstimationInner = (selectedMarket, actions, client, netwo
     return rates;
 });
 export const getApyAfterValuesEstimation = (selectedMarket, actions, provider, network) => __awaiter(void 0, void 0, void 0, function* () { return getApyAfterValuesEstimationInner(selectedMarket, actions, getViemProvider(provider, network), network); });
+/**
+ * won't cover all cases
+ */
+export const getAaveUnderlyingSymbol = (_symbol = '') => {
+    let symbol = _symbol
+        .replace(/^aEthLido/, '')
+        .replace(/^aEthEtherFi/, '')
+        .replace(/^aEth/, '')
+        .replace(/^aArb/, '')
+        .replace(/^aOpt/, '')
+        .replace(/^aBas/, '');
+    if (symbol.startsWith('a'))
+        symbol = symbol.slice(1);
+    return wethToEth(symbol);
+};

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

@@ -56,3 +56,4 @@ export declare const getRewardsForMarket: (marketId: string, network?: NetworkNu
     supplyApy: string;
     borrowApy: string;
 }>;
+export declare const getMorphoUnderlyingSymbol: (_symbol: string) => any;

package/esm/helpers/morphoBlueHelpers/index.js

@@ -14,7 +14,7 @@ import { calculateNetApy } from '../../staking';
 import { NetworkNumber, } from '../../types/common';
 import { borrowOperations, SECONDS_PER_YEAR, WAD } from '../../constants';
 import { MorphoBlueViewContractViem } from '../../contracts';
-import { compareAddresses, DEFAULT_TIMEOUT } from '../../services/utils';
+import { compareAddresses, DEFAULT_TIMEOUT, wethToEth } from '../../services/utils';
 import { getViemProvider } from '../../services/viem';
 export const getMorphoBlueAggregatedPositionData = ({ usedAssets, assetsData, marketInfo }) => {
     var _a, _b, _c, _d, _e, _f;
@@ -348,3 +348,8 @@ export const getRewardsForMarket = (marketId_1, ...args_1) => __awaiter(void 0,
     const borrowAprPercent = new Dec(borrowApr).mul(100).toString();
     return { supplyApy: aprToApy(supplyAprPercent), borrowApy: aprToApy(borrowAprPercent) };
 });
+export const getMorphoUnderlyingSymbol = (_symbol) => {
+    if (_symbol === 'MORPHO Legacy')
+        return 'MORPHO';
+    return wethToEth(_symbol);
+};

package/esm/index.d.ts

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

package/esm/index.js

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

package/esm/liquity/index.d.ts

@@ -8,3 +8,14 @@ export declare const getLiquityAccountBalances: (provider: EthereumProvider, net
 export declare const getDebtInFront: (provider: EthereumProvider, address: EthAddress) => Promise<string>;
 export declare const _getLiquityTroveInfo: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<LiquityTroveInfo>;
 export declare const getLiquityTroveInfo: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress) => Promise<LiquityTroveInfo>;
+export declare const getLiquityStakingData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<{
+    totalLUSDDeposited: string;
+    totalLQTYStaked: string;
+    stakedLQTY: string;
+    stakedLUSDBalance: string;
+    rewardETH: string;
+    rewardLUSD: string;
+    stabilityRewardETH: string;
+    stabilityRewardLQTY: string;
+    showStakingBalances: boolean;
+}>;

package/esm/liquity/index.js

@@ -10,10 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
 import { NetworkNumber, } from '../types/common';
-import { LiquityActivePoolContractViem, LiquityCollSurplusPoolContractViem, LiquityPriceFeedContractViem, LiquityTroveManagerContractViem, LiquityViewContractViem, } from '../contracts';
+import { LiquityActivePoolContractViem, LiquityCollSurplusPoolContractViem, LiquityLQTYStakingViem, LiquityPriceFeedContractViem, LiquityStabilityPoolViem, LiquityTroveManagerContractViem, LiquityViewContractViem, } from '../contracts';
 import { LIQUITY_TROVE_STATUS_ENUM } from '../types';
 import { ZERO_ADDRESS } from '../constants';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getEthAmountForDecimals } from '../services/utils';
 export const LIQUITY_NORMAL_MODE_RATIO = 110; // MCR
 export const LIQUITY_RECOVERY_MODE_RATIO = 150; // CCR
 export const _getLiquityAccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
@@ -85,3 +86,39 @@ export const _getLiquityTroveInfo = (provider, network, address) => __awaiter(vo
     return payload;
 });
 export const getLiquityTroveInfo = (provider, network, address) => __awaiter(void 0, void 0, void 0, function* () { return _getLiquityTroveInfo(getViemProvider(provider, network, { batch: { multicall: true } }), network, address); });
+export const getLiquityStakingData = (provider, network, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const lqtyStakingView = LiquityLQTYStakingViem(provider, network);
+    const stabilityPoolView = LiquityStabilityPoolViem(provider, network);
+    const [stakes, pendingETHGain, pendingLUSDGain, totalLQTYStakes, stabilityPoolETHGain, stabilityPoolLQTYGain, compoundedLUSDDeposit, totalLUSDDeposits,] = yield Promise.all([
+        lqtyStakingView.read.stakes([address]),
+        lqtyStakingView.read.getPendingETHGain([address]),
+        lqtyStakingView.read.getPendingLUSDGain([address]),
+        lqtyStakingView.read.totalLQTYStaked(),
+        stabilityPoolView.read.getDepositorETHGain([address]),
+        stabilityPoolView.read.getDepositorLQTYGain([address]),
+        stabilityPoolView.read.getCompoundedLUSDDeposit([address]),
+        stabilityPoolView.read.getTotalLUSDDeposits(),
+    ]);
+    const totalLUSDDeposited = getEthAmountForDecimals(totalLUSDDeposits, 18);
+    const totalLQTYStaked = getEthAmountForDecimals(totalLQTYStakes, 18);
+    const stakedLQTY = getEthAmountForDecimals(stakes, 18);
+    const stakedLUSDBalance = getEthAmountForDecimals(compoundedLUSDDeposit, 18);
+    const rewardETH = getEthAmountForDecimals(pendingETHGain, 18);
+    const rewardLUSD = getEthAmountForDecimals(pendingLUSDGain, 18);
+    const stabilityRewardETH = getEthAmountForDecimals(stabilityPoolETHGain, 18);
+    const stabilityRewardLQTY = getEthAmountForDecimals(stabilityPoolLQTYGain, 18);
+    const showStakingBalances = !!(+stakedLQTY || +stakedLUSDBalance
+        || +rewardETH || +rewardLUSD
+        || +stabilityRewardETH || +stabilityRewardLQTY);
+    return {
+        totalLUSDDeposited,
+        totalLQTYStaked,
+        stakedLQTY,
+        stakedLUSDBalance,
+        rewardETH,
+        rewardLUSD,
+        stabilityRewardETH,
+        stabilityRewardLQTY,
+        showStakingBalances,
+    };
+});

package/esm/liquityV2/index.d.ts

@@ -1,6 +1,14 @@
 import { Client, PublicClient } from 'viem';
 import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
 import { LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2TroveData, LiquityV2Versions } from '../types';
+export type SPYieldGainParameters = {
+    P: string;
+    aggWeightedDebtSum: string;
+    currentScale: string;
+    lastAggUpdateTime: string;
+    totalBoldDeposits: string;
+    yieldGainsPending: string;
+};
 export declare const _getLiquityV2MarketData: (provider: Client, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo) => Promise<LiquityV2MarketData>;
 export declare const getLiquityV2MarketData: (provider: EthereumProvider, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo) => Promise<LiquityV2MarketData>;
 export declare const _getLiquityV2UserTroveIds: (provider: PublicClient, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress) => Promise<{
@@ -15,8 +23,6 @@ export declare const getLiquityV2UserTroveIds: (provider: EthereumProvider, netw
     }[];
     nextFreeTroveIndex: string;
 }>;
-export declare const calculateDebtInFrontLiquityV2: (markets: Record<LiquityV2Versions, LiquityV2MarketData>, selectedMarket: LiquityV2Versions, allMarketsUnbackedDebts: Record<LiquityV2Versions, string>, interestRateDebtInFront: string) => string;
-export declare const getDebtInFrontForInterestRateIncludingNewDebtLiquityV2: (newDebt: string, markets: Record<LiquityV2Versions, LiquityV2MarketData>, selectedMarket: LiquityV2Versions, provider: Client, network: NetworkNumber, interestRate: string) => Promise<string>;
 export declare const getDebtInFrontForInterestRateLiquityV2: (markets: Record<LiquityV2Versions, LiquityV2MarketData>, selectedMarket: LiquityV2Versions, provider: EthereumProvider, network: NetworkNumber, isLegacy: boolean, interestRate: string, debtInFrontBeingMoved?: string) => Promise<string>;
 export declare const _getLiquityV2TroveData: (provider: Client, network: NetworkNumber, { selectedMarket, assetsData, troveId, allMarketsData, }: {
     selectedMarket: LiquityV2MarketInfo;
@@ -31,3 +37,30 @@ export declare const getLiquityV2TroveData: (provider: EthereumProvider, network
     allMarketsData: Record<LiquityV2Versions, LiquityV2MarketData>;
 }, fetchDebtInFront?: boolean) => Promise<LiquityV2TroveData>;
 export declare const getLiquityV2ClaimableCollateral: (collSurplusPoolAddress: EthAddress, account: EthAddress, provider: EthereumProvider, network: NetworkNumber) => Promise<string>;
+export type sBoldYieldParameters = {
+    WETH: string;
+    wsETH: string;
+    rETH: string;
+};
+export declare const getLiquityV2Staking: (provider: Client, network: NetworkNumber, market: LiquityV2Versions, user: EthAddress) => Promise<{
+    totalBOLDDeposited: string;
+    stakedBOLDBalance: string;
+    stabilityRewardColl: string;
+    stabilityRewardYield: string;
+    showStakingBalances: boolean;
+    debtTokenBalance: string;
+    stabilityPoolApy: string;
+}>;
+export declare const getLiquitySAndYBold: (provider: Client, network: NetworkNumber, markets: any, user: EthAddress) => Promise<{
+    spApy: string;
+    yBoldApy: string;
+    totalBoldDepositedSBold: string;
+    boldRateSBold: string;
+    maxWithdrawSBold: string;
+    totalBoldDepositedYBold: string;
+    boldRateYBold: string;
+    maxWithdrawYBold: string;
+    sBoldBalance: string;
+    yBoldBalance: string;
+    stYBoldBalance: string;
+}>;

package/esm/liquityV2/index.js

@@ -9,13 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
-import { createViemContractFromConfigFunc, LiquityV2LegacyViewContractViem, LiquityV2ViewContractViem, } from '../contracts';
+import { createViemContractFromConfigFunc, LiquityV2LegacyViewContractViem, LiquityV2sBoldVaultViem, LiquityV2ViewContractViem, } from '../contracts';
 import { IncentiveKind, NetworkNumber, } from '../types/common';
 import { LIQUITY_V2_TROVE_STATUS_ENUM, LiquityV2Versions, } from '../types';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
 import { getLiquityV2AggregatedPositionData } from '../helpers/liquityV2Helpers';
-import { compareAddresses, ethToWeth, MAXUINT } from '../services/utils';
-import { ZERO_ADDRESS } from '../constants';
+import { compareAddresses, ethToWeth, getEthAmountForDecimals, MAXUINT, } from '../services/utils';
+import { SECONDS_PER_YEAR, ZERO_ADDRESS } from '../constants';
 import { LiquityV2Markets } from '../markets';
 import { getViemProvider } from '../services/viem';
 const getLiquityV2ViewContract = (provider, network, isLegacy) => {
@@ -190,40 +190,12 @@ const getAllMarketsUnbackedDebts = (markets, isLegacy, provider, network) => __a
     })));
     return Object.fromEntries(allMarketsUnbackedDebt);
 });
-export const calculateDebtInFrontLiquityV2 = (markets, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront) => {
-    // Sanity check to avoid division by 0. Very unlikely to ever happen.
-    const selectedMarketTotalBorrow = new Dec(markets[selectedMarket].assetsData[LiquityV2Markets(NetworkNumber.Eth)[selectedMarket].debtToken].totalBorrow);
-    if (selectedMarketTotalBorrow.eq(0))
-        return new Dec(0).toString();
+const calculateDebtInFrontLiquityV2 = (markets, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront) => {
     const selectedMarketUnbackedDebt = new Dec(allMarketsUnbackedDebts[selectedMarket]);
     const { isLegacy } = LiquityV2Markets(NetworkNumber.Eth)[selectedMarket];
-    const totalUnbackedDebt = Object.values(allMarketsUnbackedDebts).reduce((acc, val) => acc.plus(new Dec(val)), new Dec(0));
-    // When totalUnbackedDebt is 0, redemptions will be proportional with the branch size and not to unbacked debt.
-    // When unbacked debt is 0 for branch, next redemption call won't touch that branch, so in order to estimate total debt in front we will:
-    // - First add up all the unbacked debt from other branches, as that will be the only debt that will be redeemed on the fist redemption call
-    // - Perform split the same way as we would do when totalUnbackedDebt == 0, this would represent the second call to the redemption function
-    if (selectedMarketUnbackedDebt.eq(0)) {
-        // Special case if the branch debt in front is 0, it means that all debt in front is unbacked debt from other branches.
-        if (new Dec(interestRateDebtInFront).eq(0))
-            return totalUnbackedDebt.toString();
-        // Then calculate how much of that estimated amount would go to each branch
-        // Second redemption call - calculate proportional redemption based on updated total debt
-        const amountBeingRedeemedOnEachMarketByTotalBorrow = Object.entries(markets).map(([version, market]) => {
-            const { isLegacy: isLegacyMarket } = LiquityV2Markets(NetworkNumber.Eth)[version];
-            if (version === selectedMarket && isLegacyMarket !== isLegacy)
-                return new Dec(interestRateDebtInFront);
-            const { assetsData } = market;
-            const { debtToken } = LiquityV2Markets(NetworkNumber.Eth)[version];
-            // For other markets, subtract their unbacked debt as it will be cleared in first redemption call
-            const marketUnbackedDebt = new Dec(allMarketsUnbackedDebts[version]);
-            const totalBorrow = new Dec(assetsData[debtToken].totalBorrow).sub(marketUnbackedDebt);
-            const amountToRedeem = new Dec(interestRateDebtInFront).mul(totalBorrow).div(selectedMarketTotalBorrow);
-            return Dec.min(amountToRedeem, totalBorrow);
-        });
-        const redemptionAmount = amountBeingRedeemedOnEachMarketByTotalBorrow.reduce((acc, val) => acc.plus(val), new Dec(0));
-        return totalUnbackedDebt.plus(redemptionAmount).toString();
-    }
-    const amountBeingRedeemedOnEachMarketByUnbackedDebt = Object.entries(markets).map(([version, market]) => {
+    if (selectedMarketUnbackedDebt.eq(0))
+        return interestRateDebtInFront;
+    const amountBeingReedemedOnEachMarket = Object.entries(markets).map(([version, market]) => {
         const { isLegacy: isLegacyMarket } = LiquityV2Markets(NetworkNumber.Eth)[version];
         if (version === selectedMarket && isLegacyMarket !== isLegacy)
             return new Dec(interestRateDebtInFront);
@@ -231,24 +203,11 @@ export const calculateDebtInFrontLiquityV2 = (markets, selectedMarket, allMarket
         const { debtToken } = LiquityV2Markets(NetworkNumber.Eth)[version];
         const unbackedDebt = new Dec(allMarketsUnbackedDebts[version]);
         const totalBorrow = new Dec(assetsData[debtToken].totalBorrow);
-        const amountToRedeem = new Dec(interestRateDebtInFront).mul(unbackedDebt).div(selectedMarketUnbackedDebt);
-        return Dec.min(amountToRedeem, totalBorrow);
+        const amountToReedem = new Dec(interestRateDebtInFront).mul(unbackedDebt).div(selectedMarketUnbackedDebt);
+        return Dec.min(amountToReedem, totalBorrow);
     });
-    return amountBeingRedeemedOnEachMarketByUnbackedDebt.reduce((acc, val) => acc.plus(val), new Dec(0)).toString();
+    return amountBeingReedemedOnEachMarket.reduce((acc, val) => acc.plus(val), new Dec(0)).toString();
 };
-// @dev The amount redeemed on each branch depends on the unbacked debt of every branch (the difference between total borrow and stability pool deposits).
-// When new debt is generated on the selected market, the unbacked debt will increase, resulting in a higher redemption amount on that branch.
-// This function accepts the new debt that's about to be generated (e.g., trove creation) and estimates the debt in front based on the new state.
-export const getDebtInFrontForInterestRateIncludingNewDebtLiquityV2 = (newDebt, markets, selectedMarket, provider, network, interestRate) => __awaiter(void 0, void 0, void 0, function* () {
-    const marketsWithNewDebt = structuredClone(markets);
-    const selectedMarketDebtToken = LiquityV2Markets(network)[selectedMarket].debtToken;
-    const currentTotalBorrow = new Dec(marketsWithNewDebt[selectedMarket].assetsData[selectedMarketDebtToken].totalBorrow);
-    marketsWithNewDebt[selectedMarket].assetsData[selectedMarketDebtToken].totalBorrow = currentTotalBorrow.add(newDebt).toString();
-    const { isLegacy } = LiquityV2Markets(NetworkNumber.Eth)[selectedMarket];
-    const allMarketsUnbackedDebts = yield getAllMarketsUnbackedDebts(marketsWithNewDebt, isLegacy, provider, network);
-    const interestRateDebtInFront = new Dec(yield getDebtInFrontForInterestRateSingleMarketLiquityV2(provider, network, isLegacy, LiquityV2Markets(network)[selectedMarket].marketAddress, interestRate));
-    return calculateDebtInFrontLiquityV2(marketsWithNewDebt, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront.toString());
-});
 const getDebtInFrontLiquityV2 = (markets, selectedMarket, provider, network, viewContract, troveId) => __awaiter(void 0, void 0, void 0, function* () {
     const { isLegacy } = LiquityV2Markets(NetworkNumber.Eth)[selectedMarket];
     const allMarketsUnbackedDebts = yield getAllMarketsUnbackedDebts(markets, isLegacy, provider, network);
@@ -335,3 +294,142 @@ export const getLiquityV2ClaimableCollateral = (collSurplusPoolAddress, account,
     const claimableCollateral = yield collSurplusPoolContract.read.getCollateral([account]);
     return claimableCollateral.toString();
 });
+const stabilityPoolAddrForMarket = {
+    [LiquityV2Versions.LiquityV2Eth]: '0x5721cbbd64fc7Ae3Ef44A0A3F9a790A9264Cf9BF',
+    [LiquityV2Versions.LiquityV2WstEth]: '0x9502b7c397e9aa22fe9db7ef7daf21cd2aebe56b',
+    [LiquityV2Versions.LiquityV2REth]: '0xd442e41019b7f5c4dd78f50dc03726c446148695',
+    [LiquityV2Versions.LiquityV2EthLegacy]: ZERO_ADDRESS,
+    [LiquityV2Versions.LiquityV2REthLegacy]: ZERO_ADDRESS,
+    [LiquityV2Versions.LiquityV2WstEthLegacy]: ZERO_ADDRESS,
+};
+const activePoolAddrForMarket = {
+    [LiquityV2Versions.LiquityV2Eth]: '0xeB5A8C825582965f1d84606E078620a84ab16AfE',
+    [LiquityV2Versions.LiquityV2WstEth]: '0x531a8f99c70d6a56a7cee02d6b4281650d7919a0',
+    [LiquityV2Versions.LiquityV2REth]: '0x9074d72cc82dad1e13e454755aa8f144c479532f',
+    [LiquityV2Versions.LiquityV2EthLegacy]: ZERO_ADDRESS,
+    [LiquityV2Versions.LiquityV2WstEthLegacy]: ZERO_ADDRESS,
+    [LiquityV2Versions.LiquityV2REthLegacy]: ZERO_ADDRESS,
+};
+function ceilDiv(a, b) {
+    return new Dec(a).add(new Dec(b).sub(1)).div(b).toString();
+}
+const SP_YIELD_SPLIT = new Dec(75).mul(Math.pow(10, 16)).toString(); // 75%
+const calcPendingSPYield = (aggWeightedDebtSum, lastAggUpdateTime, currentTime) => {
+    const a = new Dec(aggWeightedDebtSum).mul(new Dec(currentTime).sub(new Dec(lastAggUpdateTime))).toString();
+    const b = new Dec(SECONDS_PER_YEAR).mul(1000).mul(1e18).toString();
+    return new Dec(ceilDiv(a, b)).mul(SP_YIELD_SPLIT).div(1e18).toString();
+};
+const calculateStabilityPoolApy = (spYieldGainParams) => {
+    const { aggWeightedDebtSum, totalBoldDeposits, lastAggUpdateTime, yieldGainsPending, } = spYieldGainParams;
+    if (new Dec(totalBoldDeposits).eq(0)) {
+        return '0';
+    }
+    const now = Date.now().toString();
+    const lastAggUpdateTimeScaled = new Dec(lastAggUpdateTime).mul(1000).toString();
+    const pendingSPYield = new Dec(calcPendingSPYield(aggWeightedDebtSum, lastAggUpdateTimeScaled, now)).add(yieldGainsPending).toString();
+    const annualizedYield = new Dec(pendingSPYield).mul(SECONDS_PER_YEAR).mul(1000).div(new Dec(now).minus(lastAggUpdateTimeScaled))
+        .toString();
+    return new Dec(annualizedYield).div(totalBoldDeposits).mul(100).toString();
+};
+const getYBoldApyApi = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const url = 'https://ydaemon.yearn.fi/1/vaults/0x23346B04a7f55b8760E5860AA5A77383D63491cD?strategiesDetails=withDetails&strategiesCondition=inQueue';
+        const yBoldData = yield fetch(url)
+            .then(res => res.json())
+            .catch(console.error);
+        return new Dec(yBoldData.apr.netAPR).mul(100).toString();
+    }
+    catch (error) {
+        console.error('External API Failure: YBold ', error);
+        return '0';
+    }
+});
+const calculateSPApy = (spYieldGainParams, spAPYs) => {
+    const { WETH, wsETH, rETH, } = spYieldGainParams;
+    const apy = new Dec(WETH).mul(spAPYs.apyEth).add(new Dec(wsETH).mul(spAPYs.apyWstEth)).add(new Dec(rETH).mul(spAPYs.apyREth))
+        .toString();
+    return apy;
+};
+export const getLiquityV2Staking = (provider, network, market, user) => __awaiter(void 0, void 0, void 0, function* () {
+    const stabilityPoolView = createViemContractFromConfigFunc('LiquityV2StabilityPool', stabilityPoolAddrForMarket[market])(provider, network);
+    const activePoolView = createViemContractFromConfigFunc('LiquityV2ActivePool', activePoolAddrForMarket[market])(provider, network);
+    const debtTokenInfo = getAssetInfo(LiquityV2Markets(network)[market].debtToken, network);
+    const debtTokenContract = createViemContractFromConfigFunc('Erc20', debtTokenInfo.address)(provider, network);
+    const [stabilityRewardColl, stabilityRewardYield, compoundedBoldDeposit, totalBoldDeposits, P, currentScale, yieldGainsPending, debtTokenBalance, aggWeightedDebtSum, lastAggUpdateTime,] = yield Promise.all([
+        stabilityPoolView.read.getDepositorCollGain([user]),
+        stabilityPoolView.read.getDepositorYieldGain([user]),
+        stabilityPoolView.read.getCompoundedBoldDeposit([user]),
+        stabilityPoolView.read.getTotalBoldDeposits(),
+        stabilityPoolView.read.P(),
+        stabilityPoolView.read.currentScale(),
+        stabilityPoolView.read.getYieldGainsPending(),
+        debtTokenContract.read.balanceOf([user]),
+        activePoolView.read.aggWeightedDebtSum(),
+        activePoolView.read.lastAggUpdateTime(),
+    ]);
+    const stabilityPoolYieldParams = {
+        aggWeightedDebtSum: aggWeightedDebtSum.toString(),
+        lastAggUpdateTime: lastAggUpdateTime.toString(),
+        P: P.toString(),
+        currentScale: currentScale.toString(),
+        yieldGainsPending: yieldGainsPending.toString(),
+        totalBoldDeposits: totalBoldDeposits.toString(),
+    };
+    const stabilityPoolApy = calculateStabilityPoolApy(stabilityPoolYieldParams);
+    const stakedBOLDBalanceForUser = getEthAmountForDecimals(compoundedBoldDeposit.toString(), 18);
+    const stabilityRewardCollForUser = getEthAmountForDecimals(stabilityRewardColl.toString(), 18);
+    const stabilityRewardYieldForUser = getEthAmountForDecimals(stabilityRewardYield.toString(), 18);
+    return {
+        totalBOLDDeposited: getEthAmountForDecimals(totalBoldDeposits.toString(), 18),
+        stakedBOLDBalance: stakedBOLDBalanceForUser,
+        stabilityRewardColl: stabilityRewardCollForUser,
+        stabilityRewardYield: stabilityRewardYieldForUser,
+        showStakingBalances: !!(+stakedBOLDBalanceForUser || +stabilityRewardCollForUser || +stabilityRewardYieldForUser),
+        debtTokenBalance: getEthAmountForDecimals(debtTokenBalance.toString(), debtTokenInfo.decimals),
+        stabilityPoolApy,
+    };
+});
+export const getLiquitySAndYBold = (provider, network, markets, user) => __awaiter(void 0, void 0, void 0, function* () {
+    const sBold = LiquityV2sBoldVaultViem(provider, network);
+    const yBold = createViemContractFromConfigFunc('Erc4626', '0x9F4330700a36B29952869fac9b33f45EEdd8A3d8')(provider, network);
+    const stYBold = createViemContractFromConfigFunc('Erc4626', '0x23346B04a7f55b8760E5860AA5A77383D63491cD')(provider, network);
+    const spAPYs = {
+        apyEth: markets[LiquityV2Versions.LiquityV2Eth].data.stabilityPoolApy,
+        apyWstEth: markets[LiquityV2Versions.LiquityV2WstEth].data.stabilityPoolApy,
+        apyREth: markets[LiquityV2Versions.LiquityV2REth].data.stabilityPoolApy,
+    };
+    const [sBoldTotalAssets, sBoldConvertToShares, sBoldMaxWithdraw, wethApy, wsETHApy, rETHApy, yBoldTotalAssets, yBoldMaxWithdraw, stYBoldConvertToShares, yBoldApy, sBoldBalance, yBoldBalance, stYBoldBalance,] = yield Promise.all([
+        sBold.read.totalAssets(),
+        sBold.read.convertToShares([BigInt(1e18)]),
+        sBold.read.maxWithdraw([user]),
+        sBold.read.sps([BigInt(0)]),
+        sBold.read.sps([BigInt(1)]),
+        sBold.read.sps([BigInt(2)]),
+        yBold.read.totalAssets(),
+        yBold.read.maxWithdraw([user]),
+        stYBold.read.convertToShares([BigInt(1e18)]),
+        getYBoldApyApi(),
+        sBold.read.balanceOf([user]),
+        yBold.read.balanceOf([user]),
+        stYBold.read.balanceOf([user]),
+    ]);
+    const spMarketRes = {
+        WETH: new Dec(wethApy[1]).div(10000).toString(),
+        wsETH: new Dec(wsETHApy[1]).div(10000).toString(),
+        rETH: new Dec(rETHApy[1]).div(10000).toString(),
+    };
+    const spApy = calculateSPApy(spMarketRes, spAPYs);
+    return {
+        spApy,
+        yBoldApy,
+        totalBoldDepositedSBold: assetAmountInEth(sBoldTotalAssets.toString(), 'sBOLD'),
+        boldRateSBold: assetAmountInEth(sBoldConvertToShares.toString(), 'sBOLD'),
+        maxWithdrawSBold: assetAmountInEth(sBoldMaxWithdraw.toString(), 'sBOLD'),
+        totalBoldDepositedYBold: assetAmountInEth(yBoldTotalAssets.toString(), 'yBOLD'),
+        boldRateYBold: assetAmountInEth(stYBoldConvertToShares.toString(), 'yBOLD'),
+        maxWithdrawYBold: assetAmountInEth(yBoldMaxWithdraw.toString(), 'yBOLD'),
+        sBoldBalance: assetAmountInEth(sBoldBalance.toString(), 'sBOLD'),
+        yBoldBalance: assetAmountInEth(yBoldBalance.toString(), 'yBOLD'),
+        stYBoldBalance: assetAmountInEth(stYBoldBalance.toString(), 'yBOLD'),
+    };
+});

package/esm/morphoBlue/index.d.ts

@@ -7,3 +7,8 @@ export declare const _getMorphoBlueAccountBalances: (provider: Client, network:
 export declare const getMorphoBlueAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoBlueMarketData) => Promise<PositionBalances>;
 export declare function _getMorphoBlueAccountData(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBluePositionData>;
 export declare function getMorphoBlueAccountData(provider: EthereumProvider, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBluePositionData>;
+export declare function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<{
+    apy: string;
+    amount: string;
+    amountUsd: string;
+}>;

package/esm/morphoBlue/index.js

@@ -12,7 +12,7 @@ import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
 import { IncentiveKind, NetworkNumber, } from '../types/common';
 import { DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoBlueViewContractViem, } from '../contracts';
 import { USD_QUOTE, WAD } from '../constants';
-import { getStakingApy, STAKING_ASSETS } from '../staking';
+import { calculateNetApy, getStakingApy, STAKING_ASSETS } from '../staking';
 import { isMainnetNetwork, wethToEth } from '../services/utils';
 import { getBorrowRate, getMorphoBlueAggregatedPositionData, getRewardsForMarket, getSupplyRate, } from '../helpers/morphoBlueHelpers';
 import { getChainlinkAssetAddress } from '../services/priceService';
@@ -201,3 +201,37 @@ export function getMorphoBlueAccountData(provider, network, account, selectedMar
         return _getMorphoBlueAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
     });
 }
+export function getMorphoEarn(provider, network, account, selectedMarket, marketInfo) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { loanToken, collateralToken, oracle, irm, lltv, } = selectedMarket;
+        const lltvInWei = new Dec(lltv).mul(WAD).toString();
+        const viewContract = MorphoBlueViewContractViem(provider, network);
+        const loanInfo = (yield viewContract.read.getUserInfo([
+            {
+                loanToken, collateralToken, oracle, irm, lltv: BigInt(lltvInWei),
+            },
+            account
+        ]));
+        const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
+        const loanTokenSupplied = assetAmountInEth(loanInfo.suppliedInAssets.toString(), marketInfo.loanToken);
+        const loanTokenSuppliedUsd = new Dec(loanTokenSupplied).mul(loanTokenInfo.price).toString();
+        const usedAssets = {
+            [marketInfo.loanToken]: {
+                symbol: loanTokenInfo.symbol,
+                supplied: loanTokenSupplied,
+                borrowed: '0',
+                isSupplied: new Dec(loanInfo.suppliedInAssets.toString()).gt(0),
+                isBorrowed: false,
+                collateral: false,
+                suppliedUsd: loanTokenSuppliedUsd,
+                borrowedUsd: '0',
+            },
+        };
+        const { netApy } = calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData });
+        return {
+            apy: netApy,
+            amount: loanTokenSupplied,
+            amountUsd: loanTokenSuppliedUsd,
+        };
+    });
+}

package/esm/portfolio/index.d.ts

@@ -1,3 +1,8 @@
 import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
 import { PortfolioPositionsData } from '../types';
-export declare function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], summerFiAddresses: EthAddress[]): Promise<PortfolioPositionsData>;
+export declare function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], summerFiAddresses: EthAddress[]): Promise<{
+    positions: PortfolioPositionsData;
+    stakingPositions: any;
+    rewardsData: any;
+    markets: any;
+}>;