import Dec from 'decimal.js'; import memoize from 'memoizee'; import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens'; import { Client, PublicClient } from 'viem'; import { createViemContractFromConfigFunc, LiquityV2LegacyViewContractViem, LiquityV2sBoldVaultViem, LiquityV2ViewContractViem, } from '../contracts'; import { EthAddress, EthereumProvider, IncentiveKind, NetworkNumber, HexString, } from '../types/common'; import { LIQUITY_V2_TROVE_STATUS_ENUM, LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2SBoldYBoldData, LiquityV2StakingData, LiquityV2TroveData, LiquityV2UsedAssets, LiquityV2Versions, } from '../types'; import { getStakingApy, STAKING_ASSETS } from '../staking'; import { getLiquityV2AggregatedPositionData } from '../helpers/liquityV2Helpers'; import { compareAddresses, DEFAULT_TIMEOUT, ethToWeth, getEthAmountForDecimals, MAXUINT, } from '../services/utils'; import { SECONDS_PER_YEAR, ZERO_ADDRESS } from '../constants'; import { LiquityV2Markets } from '../markets'; import { getViemProvider } from '../services/viem'; export type SPYieldGainParameters = { P: string; aggWeightedDebtSum: string; currentScale: string; lastAggUpdateTime: string; totalBoldDeposits: string; yieldGainsPending: string; }; const getLiquityV2ViewContract = (provider: Client, network: NetworkNumber, isLegacy: boolean) => { if (isLegacy) return LiquityV2LegacyViewContractViem(provider, network); return LiquityV2ViewContractViem(provider, network); }; export const _getLiquityV2MarketData = async (provider: Client, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo): Promise => { const { marketAddress, debtToken, collateralToken, isLegacy, } = selectedMarket; const data = isLegacy ? await LiquityV2LegacyViewContractViem(provider, network).read.getMarketData([marketAddress]) : (await LiquityV2ViewContractViem(provider, network).simulate.getMarketData([marketAddress])).result; const hintHelperAddress = data.hintHelpers; const troveNFTAddress = data.troveNFT; const borrowerOperationsAddress = data.borrowerOperations; const troveManagerAddress = data.troveManager; const stabilityPoolAddress = data.stabilityPool; const collSurplusPoolAddress = data.collSurplusPool; const activePoolAddress = data.activePool; const minCollRatio = new Dec(data.MCR).div(1e16).toString(); const criticalCollRatio = new Dec(data.CCR).div(1e18).toString(); // @ts-ignore const batchCollRatio = new Dec(data.BCR ?? '0').div(1e16).toString(); const totalMarketBorrow = assetAmountInEth(data.entireSystemDebt.toString()); const totalMarketSupply = assetAmountInEth(data.entireSystemColl.toString()); const collPrice = assetAmountInEth(data.collPrice.toString()); const totalCollRatio = new Dec(totalMarketSupply).mul(collPrice).div(totalMarketBorrow).toString(); const leftToBorrowGlobal = new Dec(totalMarketSupply).mul(collPrice).div(criticalCollRatio).sub(totalMarketBorrow) .toString(); const minCollAmountForCurrentBorrow = new Dec(totalMarketBorrow).mul(criticalCollRatio).div(collPrice).toString(); const leftToWithdrawGlobal = new Dec(totalMarketSupply).sub(minCollAmountForCurrentBorrow).toString(); const assetsData: LiquityV2AssetsData = {}; assetsData[debtToken] = { symbol: debtToken, address: getAssetInfo(debtToken, network).address, price: '1', totalSupply: '0', totalBorrow: totalMarketBorrow, canBeSupplied: false, canBeBorrowed: true, leftToBorrowGlobal, leftToWithdrawGlobal: '0', supplyIncentives: [], borrowIncentives: [], }; assetsData[collateralToken] = { symbol: collateralToken, address: getAssetInfo(ethToWeth(collateralToken), network).address, price: collPrice, totalSupply: totalMarketSupply, totalBorrow: '0', canBeSupplied: true, canBeBorrowed: false, leftToBorrowGlobal: '0', leftToWithdrawGlobal, supplyIncentives: [], borrowIncentives: [], }; if (STAKING_ASSETS.includes(collateralToken)) { assetsData[collateralToken].supplyIncentives.push({ apy: await getStakingApy(collateralToken), token: collateralToken, incentiveKind: IncentiveKind.Staking, description: `Native ${collateralToken} yield.`, }); } return { assetsData, marketData: { minCollRatio, totalCollRatio: new Dec(totalCollRatio).mul(100).toString(), criticalCollRatio: new Dec(criticalCollRatio).mul(100).toString(), batchCollRatio, isUnderCollateralized: new Dec(totalCollRatio).lt(criticalCollRatio), hintHelperAddress, troveNFTAddress, borrowerOperationsAddress, troveManagerAddress, stabilityPoolAddress, collSurplusPoolAddress, activePoolAddress, }, }; }; export const getLiquityV2MarketData = async ( provider: EthereumProvider, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, ): Promise => _getLiquityV2MarketData(getViemProvider(provider, network), network, selectedMarket); const getUserTroves = async ( provider: Client, network: NetworkNumber, isLegacy: boolean, account: EthAddress, marketAddress: EthAddress, startIndex = 0, endIndex = 100, troves: { troveId: string, ownedByUser: boolean }[] = [], ): Promise<{ troves: { troveId: string, ownedByUser: boolean }[], nextFreeTroveIndex: string }> => { const viewContract = getLiquityV2ViewContract(provider, network, isLegacy); const result = await viewContract.read.getUserTroves([account, marketAddress, BigInt(startIndex), BigInt(endIndex)]); const newStartIndex = endIndex + 1; const nextFreeTroveIndex = result[1].toString(); const existingTroves = [...troves, ...result[0].map((trove: any) => ({ ...trove, troveId: trove.troveId.toString() }))]; if (nextFreeTroveIndex !== '-1') return { troves: existingTroves.filter((trove) => trove.ownedByUser), nextFreeTroveIndex }; return getUserTroves(provider, network, isLegacy, account, marketAddress, newStartIndex, newStartIndex + 100, existingTroves); }; export const nftContractCreationBlockMapping = { [LiquityV2Versions.LiquityV2Eth]: 22516079, [LiquityV2Versions.LiquityV2WstEth]: 22516099, [LiquityV2Versions.LiquityV2REth]: 22516118, // legacy [LiquityV2Versions.LiquityV2EthLegacy]: 21686215, [LiquityV2Versions.LiquityV2WstEthLegacy]: 21686238, [LiquityV2Versions.LiquityV2REthLegacy]: 21686257, }; interface TroveTransfer { from?: EthAddress, to?: EthAddress, tokenId: string, blockNumber: number, } /** Every Transfer of a market's trove NFT since the contract was created (or, on a fork, in the last 1000 blocks). */ const getTroveTransfers = async (provider: PublicClient, network: NetworkNumber, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, market: LiquityV2Versions): Promise => { const nftContract = createViemContractFromConfigFunc('LiquityV2TroveNFT', troveNFTAddress)(provider, network); const nftContractCreationBlock = nftContractCreationBlockMapping[market]; const currentBlock = +(await provider.getBlockNumber()).toString(); const _events = await nftContract.getEvents.Transfer({}, { fromBlock: limitBlocksForEventFetching ? BigInt(currentBlock - 1000) : BigInt(nftContractCreationBlock) }); return _events.map((event) => ({ from: event.args.from, to: event.args.to, tokenId: event.args.tokenId!.toString(), blockNumber: +(event.blockNumber.toString()), })); }; /** The troves transferred to an account that it still holds: no later transfer of the same trove. */ const getAccountTransferredTroves = (events: TroveTransfer[], account: EthAddress): { troveId: string }[] => events .filter((event) => compareAddresses(event.to, account)) .filter((event) => !events.some((e) => event.blockNumber < e.blockNumber && e.tokenId === event.tokenId)) .map((event) => ({ troveId: event.tokenId })); const getTransferredTroves = async (provider: PublicClient, network: NetworkNumber, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, market: LiquityV2Versions, account: EthAddress): Promise<{ troveId: string }[]> => ( getAccountTransferredTroves(await getTroveTransfers(provider, network, troveNFTAddress, limitBlocksForEventFetching, market), account)); /** The troves an account opened and still owns, then the ones transferred to it, each once. */ const mergeTroveIds = (userTroves: { troveId: string }[], userTransferredTroves: { troveId: string }[]): { troveId: string }[] => { const troves = [...userTroves.map(({ troveId }) => ({ troveId })), ...userTransferredTroves]; const filteredTroves = troves.filter((value, index, self) => index === self.findIndex((t) => ( t.troveId === value.troveId )), ); const troveIds = filteredTroves.map((trove) => trove.troveId); const troveIdsSet = new Set(troveIds); const troveIdsArray = Array.from(troveIdsSet); return troveIdsArray.map((troveId) => troves.find((trove) => trove.troveId === troveId)) as { troveId: string }[]; }; /** * The trove ids of several accounts in one market: the market's NFT transfers are read once for all of them, rather * than once per account as _getLiquityV2UserTroveIds does. */ export const _getLiquityV2UsersTroveIds = async (provider: PublicClient, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, accounts: EthAddress[]): Promise> => { const [userTroves, events] = await Promise.all([ Promise.all(accounts.map((account) => getUserTroves(provider, network, selectedMarket.isLegacy, account, selectedMarket.marketAddress))), getTroveTransfers(provider, network, troveNFTAddress, limitBlocksForEventFetching, selectedMarket.value), ]); return Object.fromEntries(accounts.map((account, i) => [ account, mergeTroveIds(userTroves[i].troves, getAccountTransferredTroves(events, account)).map(({ troveId }) => troveId), ])); }; export const _getLiquityV2UserTroveIds = async (provider: PublicClient, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress): Promise<{ troves: { troveId: string }[], nextFreeTroveIndex: string }> => { const [{ troves: userTroves, nextFreeTroveIndex }, userTransferredTroves] = await Promise.all([ getUserTroves(provider, network, selectedMarket.isLegacy, account, selectedMarket.marketAddress), getTransferredTroves(provider, network, troveNFTAddress, limitBlocksForEventFetching, selectedMarket.value, account), ]); return { troves: mergeTroveIds(userTroves, userTransferredTroves), nextFreeTroveIndex }; }; export const getLiquityV2UserTroveIds = async ( provider: EthereumProvider, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress, ): Promise<{ troves: { troveId: string }[], nextFreeTroveIndex: string }> => _getLiquityV2UserTroveIds(getViemProvider(provider, network), network, selectedMarket, troveNFTAddress, limitBlocksForEventFetching, account); const getDebtInFrontForSingleMarketLiquityV2 = async ( provider: Client, network: NetworkNumber, isLegacy: boolean, marketAddress: EthAddress, troveId: string, accumulatedSum = '0', iterations = 2000, ): Promise => { const viewContract = getLiquityV2ViewContract(provider, network, isLegacy); const res = await viewContract.read.getDebtInFront([marketAddress, BigInt(troveId), BigInt(accumulatedSum), BigInt(iterations)]); const next = res[0].toString(); const debt = res[1].toString(); if (next === '0') return assetAmountInEth(debt); return getDebtInFrontForSingleMarketLiquityV2(provider, network, isLegacy, marketAddress, next, debt, iterations); }; const getDebtInFrontForInterestRateSingleMarketLiquityV2 = async ( provider: Client, network: NetworkNumber, isLegacy: boolean, marketAddress: EthAddress, interestRate: string, troveId = '0', accumulatedSum = '0', iterations = 2000, ): Promise => { const viewContract = getLiquityV2ViewContract(provider, network, isLegacy); if (+interestRate === 0 || !interestRate) return '0'; const interestRateWei = new Dec(interestRate).times(1e16).toFixed(0).toString(); const res = await viewContract.read.getDebtInFrontByInterestRate([marketAddress, BigInt(troveId), BigInt(accumulatedSum), BigInt(iterations), BigInt(interestRateWei)]); const next = res[0].toString(); const debt = res[1].toString(); if (next === '0') return assetAmountInEth(debt); return getDebtInFrontForInterestRateSingleMarketLiquityV2(provider, network, isLegacy, marketAddress, interestRate, next, debt, iterations); }; const getUnbackedDebtForSingleMarket = async (totalBorrowed: string, provider: Client, network: NetworkNumber, stabilityPoolAddress: EthAddress) => { const stabilityPoolContract = createViemContractFromConfigFunc('LiquityV2StabilityPool', stabilityPoolAddress)(provider, network); const totalBoldDeposits = await stabilityPoolContract.read.getTotalBoldDeposits(); const totalBoldDepositsInEth = assetAmountInEth(totalBoldDeposits.toString()); return Dec.max(new Dec(totalBorrowed).sub(totalBoldDepositsInEth), 0).toString(); }; const getAllMarketsUnbackedDebts = async (markets: Record, isLegacy: boolean, provider: Client, network: NetworkNumber): Promise> => { const allMarketsUnbackedDebt = await Promise.all(Object.entries(markets).map(async ([version, market]) => { const { assetsData, marketData } = market; const { debtToken, isLegacy: isLegacyMarket } = LiquityV2Markets(network)[version as LiquityV2Versions]; if (isLegacyMarket !== isLegacy) return [version, '0']; const unbackedDebt = await getUnbackedDebtForSingleMarket(assetsData[debtToken].totalBorrow, provider, network, marketData.stabilityPoolAddress); return [version, unbackedDebt]; })); return Object.fromEntries(allMarketsUnbackedDebt) as Record; }; export const calculateDebtInFrontLiquityV2 = (markets: Record, selectedMarket: LiquityV2Versions, allMarketsUnbackedDebts: Record, interestRateDebtInFront: string): string => { // 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 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 as LiquityV2Versions]; if (version === selectedMarket && isLegacyMarket !== isLegacy) return new Dec(interestRateDebtInFront); const { assetsData } = market; const { debtToken } = LiquityV2Markets(NetworkNumber.Eth)[version as LiquityV2Versions]; // For other markets, subtract their unbacked debt as it will be cleared in first redemption call const marketUnbackedDebt = new Dec(allMarketsUnbackedDebts[version as LiquityV2Versions]); 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]) => { const { isLegacy: isLegacyMarket } = LiquityV2Markets(NetworkNumber.Eth)[version as LiquityV2Versions]; if (version === selectedMarket && isLegacyMarket !== isLegacy) return new Dec(interestRateDebtInFront); const { assetsData } = market; const { debtToken } = LiquityV2Markets(NetworkNumber.Eth)[version as LiquityV2Versions]; const unbackedDebt = new Dec(allMarketsUnbackedDebts[version as LiquityV2Versions]); const totalBorrow = new Dec(assetsData[debtToken].totalBorrow); const amountToRedeem = new Dec(interestRateDebtInFront).mul(unbackedDebt).div(selectedMarketUnbackedDebt); return Dec.min(amountToRedeem, totalBorrow); }); return amountBeingRedeemedOnEachMarketByUnbackedDebt.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 = async (newDebt: string, markets: Record, selectedMarket: LiquityV2Versions, provider: Client, network: NetworkNumber, interestRate: string) => { 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 = await getAllMarketsUnbackedDebts(marketsWithNewDebt, isLegacy, provider, network); const interestRateDebtInFront = new Dec(await getDebtInFrontForInterestRateSingleMarketLiquityV2(provider, network, isLegacy, LiquityV2Markets(network)[selectedMarket].marketAddress, interestRate)); return calculateDebtInFrontLiquityV2(marketsWithNewDebt, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront.toString()); }; const getDebtInFrontLiquityV2 = async (markets: Record, selectedMarket: LiquityV2Versions, provider: Client, network: NetworkNumber, viewContract: any, troveId: string) => { const { isLegacy } = LiquityV2Markets(NetworkNumber.Eth)[selectedMarket]; const allMarketsUnbackedDebts = await getAllMarketsUnbackedDebts(markets, isLegacy, provider, network); const interestRateDebtInFront = await getDebtInFrontForSingleMarketLiquityV2(provider, network, isLegacy, LiquityV2Markets(network)[selectedMarket].marketAddress, troveId); return calculateDebtInFrontLiquityV2(markets, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront.toString()); }; /** * @param markets * @param selectedMarket * @param provider * @param network * @param viewContract * @param interestRate * @param debtInFrontBeingMoved - amound of debt being repositioned if interest rate is being increased (prevents including it as debt in front) */ const _getDebtInFrontForInterestRateLiquityV2 = async (markets: Record, selectedMarket: LiquityV2Versions, provider: Client, network: NetworkNumber, isLegacy: boolean, interestRate: string, debtInFrontBeingMoved: string = '0') => { const allMarketsUnbackedDebts = await getAllMarketsUnbackedDebts(markets, isLegacy, provider, network); const interestRateDebtInFront = new Dec(await getDebtInFrontForInterestRateSingleMarketLiquityV2(provider, network, isLegacy, LiquityV2Markets(network)[selectedMarket].marketAddress, interestRate)) .sub(debtInFrontBeingMoved); return calculateDebtInFrontLiquityV2(markets, selectedMarket, allMarketsUnbackedDebts, interestRateDebtInFront.toString()); }; export const getDebtInFrontForInterestRateLiquityV2 = async ( markets: Record, selectedMarket: LiquityV2Versions, provider: EthereumProvider, network: NetworkNumber, isLegacy: boolean, interestRate: string, debtInFrontBeingMoved: string = '0', ) => _getDebtInFrontForInterestRateLiquityV2(markets, selectedMarket, getViemProvider(provider, network), network, isLegacy, interestRate, debtInFrontBeingMoved); export const _getLiquityV2TroveData = async ( provider: Client, network: NetworkNumber, { selectedMarket, assetsData, troveId, allMarketsData, }: { selectedMarket: LiquityV2MarketInfo, assetsData: LiquityV2AssetsData, troveId: string, allMarketsData: Record, }, fetchDebtInFront: boolean = true, ): Promise => { const { minCollRatio, batchCollRatio } = allMarketsData[selectedMarket.value].marketData; const { collateralToken, marketAddress, debtToken } = selectedMarket; const troveInfoPromise = selectedMarket.isLegacy ? LiquityV2LegacyViewContractViem(provider, network).read.getTroveInfo([marketAddress, BigInt(troveId)]) : LiquityV2ViewContractViem(provider, network).simulate .getTroveInfo([marketAddress, BigInt(troveId)]) .then(({ result }) => result); const [_data, debtInFront] = await Promise.all([ troveInfoPromise, fetchDebtInFront ? getDebtInFrontLiquityV2(allMarketsData, selectedMarket.value, provider, network, selectedMarket.isLegacy, troveId) : Promise.resolve('0'), ]); const data = { ..._data, TCRatio: _data.TCRatio.toString() === MAXUINT ? '0' : _data.TCRatio.toString(), // mistake on contract side when debt is 0 }; const usedAssets: LiquityV2UsedAssets = {}; const debtAssetData = assetsData[debtToken]; const borrowed = assetAmountInEth(data.debtAmount.toString()); usedAssets[debtToken] = { symbol: debtToken, supplied: '0', suppliedUsd: '0', borrowed, borrowedUsd: new Dec(borrowed).mul(debtAssetData.price).toString(), isBorrowed: true, isSupplied: false, }; const collAssetData = assetsData[collateralToken]; const suppliedColl = assetAmountInEth(data.collAmount.toString()); usedAssets[collateralToken] = { symbol: collateralToken, supplied: suppliedColl, suppliedUsd: new Dec(suppliedColl).mul(collAssetData.price).toString(), borrowed: '0', borrowedUsd: '0', isBorrowed: false, isSupplied: true, collateral: true, }; const collRatio = new Dec(data.TCRatio).div(1e16).toString(); const interestRate = new Dec(data.annualInterestRate).div(1e16).toString(); const interestBatchManager = data.interestBatchManager; const lastInterestRateAdjTime = data.lastInterestRateAdjTime.toString(); const hasInterestBatchManager = !compareAddresses(interestBatchManager, ZERO_ADDRESS); const borrowLimitRatio = hasInterestBatchManager ? new Dec(minCollRatio).add(batchCollRatio).toString() : minCollRatio; const payload: LiquityV2TroveData = { usedAssets, troveId, interestRate, interestBatchManager, debtInFront, lastInterestRateAdjTime, liqRatio: minCollRatio, borrowLimitRatio, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)], ...getLiquityV2AggregatedPositionData({ usedAssets, assetsData, minCollRatio: borrowLimitRatio, interestRate, liqRatio: minCollRatio, }), collRatio, }; return payload; }; export const getLiquityV2TroveData = async ( provider: EthereumProvider, network: NetworkNumber, { selectedMarket, assetsData, troveId, allMarketsData, }: { selectedMarket: LiquityV2MarketInfo, assetsData: LiquityV2AssetsData, troveId: string, allMarketsData: Record, }, fetchDebtInFront: boolean = true, ): Promise => _getLiquityV2TroveData( getViemProvider(provider, network), network, { selectedMarket, assetsData, troveId, allMarketsData, }, fetchDebtInFront, ); export const getLiquityV2ClaimableCollateral = async (collSurplusPoolAddress: EthAddress, account: EthAddress, provider: EthereumProvider, network: NetworkNumber): Promise => { const client = getViemProvider(provider, network); const collSurplusPoolContract = createViemContractFromConfigFunc('LiquityV2CollSurplusPool', collSurplusPoolAddress)(client, network); const claimableCollateral = await collSurplusPoolContract.read.getCollateral([account]); return claimableCollateral.toString(); }; const stabilityPoolAddrForMarket: Record = { [LiquityV2Versions.LiquityV2Eth]: '0x5721cbbd64fc7Ae3Ef44A0A3F9a790A9264Cf9BF', [LiquityV2Versions.LiquityV2WstEth]: '0x9502b7c397e9aa22fe9db7ef7daf21cd2aebe56b', [LiquityV2Versions.LiquityV2REth]: '0xd442e41019b7f5c4dd78f50dc03726c446148695', [LiquityV2Versions.LiquityV2EthLegacy]: ZERO_ADDRESS, [LiquityV2Versions.LiquityV2REthLegacy]: ZERO_ADDRESS, [LiquityV2Versions.LiquityV2WstEthLegacy]: ZERO_ADDRESS, }; const activePoolAddrForMarket: Record = { [LiquityV2Versions.LiquityV2Eth]: '0xeB5A8C825582965f1d84606E078620a84ab16AfE', [LiquityV2Versions.LiquityV2WstEth]: '0x531a8f99c70d6a56a7cee02d6b4281650d7919a0', [LiquityV2Versions.LiquityV2REth]: '0x9074d72cc82dad1e13e454755aa8f144c479532f', [LiquityV2Versions.LiquityV2EthLegacy]: ZERO_ADDRESS, [LiquityV2Versions.LiquityV2WstEthLegacy]: ZERO_ADDRESS, [LiquityV2Versions.LiquityV2REthLegacy]: ZERO_ADDRESS, }; function ceilDiv(a: string, b: string) { return new Dec(a).add(new Dec(b).sub(1)).div(b).toString(); } const SP_YIELD_SPLIT = new Dec(75).mul(10 ** 16).toString(); // 75% const calcPendingSPYield = ( aggWeightedDebtSum: string, lastAggUpdateTime: string, currentTime: string, ) => { 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: SPYieldGainParameters, ) => { 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 = memoize(async () => { try { const url = 'https://ydaemon.yearn.fi/1/vaults/0x23346B04a7f55b8760E5860AA5A77383D63491cD?strategiesDetails=withDetails&strategiesCondition=inQueue'; const response = await fetch(url, { signal: AbortSignal.timeout(DEFAULT_TIMEOUT) }); if (!response.ok) throw new Error(`Failed to fetch yBold APY: ${response.status}`); const yBoldData = await response.json(); return new Dec(yBoldData.apr.netAPR).mul(100).toString(); } catch (error) { console.error('External API Failure: YBold ', error); return '0'; } }, { promise: true, maxAge: 2 * 60 * 1000 }); export type sBoldYieldParameters = { WETH: string; wsETH: string; rETH: string; }; const calculateSPApy = ( spYieldGainParams: sBoldYieldParameters, spAPYs: { apyEth: Dec.Value; apyWstEth: Dec.Value; apyREth: Dec.Value; }, ) => { 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 = async (provider: Client, network: NetworkNumber, market: LiquityV2Versions, user: EthAddress): Promise => { 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 as HexString)(provider, network); const [ stabilityRewardColl, stabilityRewardYield, compoundedBoldDeposit, totalBoldDeposits, P, currentScale, yieldGainsPending, debtTokenBalance, aggWeightedDebtSum, lastAggUpdateTime, ] = await 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: SPYieldGainParameters = { 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 = async (provider: Client, network: NetworkNumber, markets: any, user: EthAddress): Promise => { 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, ] = await 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'), }; };