@defisaver/positions-sdk 2.1.161-portfolio-api-1-dev → 2.1.161-portfolio-api-3-dev

package/src/liquity/index.ts

@@ -13,11 +13,12 @@ import {
   LiquityTroveManagerContractViem,
   LiquityViewContractViem,
 } from '../contracts';
-import { LIQUITY_TROVE_STATUS_ENUM, LiquityTroveInfo } from '../types';
+import { LIQUITY_TROVE_STATUS_ENUM, LiquityStakingData, LiquityTroveInfo } from '../types';
 import { ZERO_ADDRESS } from '../constants';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 import { getEthAmountForDecimals } from '../services/utils';
-import { getExposure } from '../moneymarket';
+import { getExposure, getSafetyRatioFromCollateralRatio } from '../moneymarket';
+import { calculateNetApyFromRates } from '../staking';
 
 export const LIQUITY_NORMAL_MODE_RATIO = 110; // MCR
 export const LIQUITY_RECOVERY_MODE_RATIO = 150; // CCR
@@ -89,6 +90,15 @@ export const _getLiquityTroveInfo = async (provider: Client, network: NetworkNum
   ]);
 
   const recoveryMode = troveInfo[6];
+  const minCollateralRatio = recoveryMode ? LIQUITY_RECOVERY_MODE_RATIO : LIQUITY_NORMAL_MODE_RATIO;
+  const collateral = assetAmountInEth(troveInfo[1].toString());
+  const debtInAsset = assetAmountInEth(troveInfo[2].toString());
+  const collateralUsd = new Dec(collateral).mul(assetAmountInEth(assetPrice.toString())).toString();
+  const collRatio = +debtInAsset ? new Dec(collateralUsd).div(debtInAsset).mul(100).toString() : '0';
+
+  // LUSD debt is interest free (only a one-off borrowing fee on issuance) and ETH collateral earns no yield,
+  // so a trove's net APY is always 0. It is exposed for parity with the other protocols.
+  const { netApy, totalInterestUsd, incentiveUsd } = calculateNetApyFromRates({ suppliedUsd: collateralUsd, borrowedUsd: debtInAsset });
 
   const payload = {
     troveStatus: LIQUITY_TROVE_STATUS_ENUM[+(troveInfo[0].toString())],
@@ -102,10 +112,14 @@ export const _getLiquityTroveInfo = async (provider: Client, network: NetworkNum
     totalETH: totalETH.toString(),
     totalLUSD: totalLUSD.toString(),
     debtInFront: debtInFront.toString(),
-    minCollateralRatio: recoveryMode ? LIQUITY_RECOVERY_MODE_RATIO : LIQUITY_NORMAL_MODE_RATIO,
+    minCollateralRatio,
+    safetyRatio: getSafetyRatioFromCollateralRatio(collRatio, minCollateralRatio),
     priceForRecovery: new Dec(recoveryMode ? LIQUITY_RECOVERY_MODE_RATIO : LIQUITY_NORMAL_MODE_RATIO).mul(totalLUSD).div(totalETH).div(100)
       .toString(),
-    exposure: getExposure(assetAmountInEth(troveInfo[2].toString()), new Dec(assetAmountInEth(troveInfo[1].toString())).mul(assetPrice).toString()),
+    exposure: getExposure(debtInAsset, collateralUsd),
+    netApy,
+    totalInterestUsd,
+    incentiveUsd,
   };
 
   return payload;
@@ -113,7 +127,7 @@ export const _getLiquityTroveInfo = async (provider: Client, network: NetworkNum
 
 export const getLiquityTroveInfo = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress): Promise<LiquityTroveInfo> => _getLiquityTroveInfo(getViemProvider(provider, network, { batch: { multicall: true } }), network, address);
 
-export const getLiquityStakingData = async (provider: Client, network: NetworkNumber, address: EthAddress) => {
+export const getLiquityStakingData = async (provider: Client, network: NetworkNumber, address: EthAddress): Promise<LiquityStakingData> => {
   const lqtyStakingView = LiquityLQTYStakingViem(provider, network);
   const stabilityPoolView = LiquityStabilityPoolViem(provider, network);
   const [

package/src/liquityV2/index.ts

@@ -12,7 +12,7 @@ import {
 } from '../types/common';
 import {
   LIQUITY_V2_TROVE_STATUS_ENUM,
-  LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2TroveData, LiquityV2UsedAssets,
+  LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2SBoldYBoldData, LiquityV2StakingData, LiquityV2TroveData, LiquityV2UsedAssets,
   LiquityV2Versions,
 } from '../types';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
@@ -162,31 +162,35 @@ const nftContractCreationBlockMapping = {
   [LiquityV2Versions.LiquityV2REthLegacy]: 21686257,
 };
 
-const getTransferredTroves = async (provider: PublicClient, network: NetworkNumber, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, market: LiquityV2Versions, account: EthAddress): Promise<{ troveId: string }[]> => {
+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<TroveTransfer[]> => {
   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) });
-  const events = _events.map((event) => ({
+  return _events.map((event) => ({
     from: event.args.from, to: event.args.to, tokenId: event.args.tokenId!.toString(), blockNumber: +(event.blockNumber.toString()),
   }));
-  const userTransferredTroves = events.filter((event) => compareAddresses(event.to, account));
-
-  // check if the last know transfer address is the user
-  userTransferredTroves.forEach((event, index) => {
-    const otherTransfers = events.filter((e) => event.blockNumber < e.blockNumber && e.tokenId === event.tokenId);
-    // @ts-ignore
-    userTransferredTroves[index].invalid = !!otherTransfers.length;
-  });
-  // @ts-ignore
-  return userTransferredTroves.filter((event) => !event.invalid).map((event) => ({ troveId: event.tokenId }));
 };
 
-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),
-  ]);
+/** 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
@@ -195,8 +199,30 @@ export const _getLiquityV2UserTroveIds = async (provider: PublicClient, network:
   const troveIds = filteredTroves.map((trove) => trove.troveId);
   const troveIdsSet = new Set(troveIds);
   const troveIdsArray = Array.from(troveIdsSet);
-  const trovesNoDuplicates = troveIdsArray.map((troveId) => troves.find((trove) => trove.troveId === troveId)) as { troveId: string }[];
-  return { troves: trovesNoDuplicates, nextFreeTroveIndex };
+  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<Record<EthAddress, string[]>> => {
+  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 (
@@ -579,7 +605,7 @@ const calculateSPApy = (
   return apy;
 };
 
-export const getLiquityV2Staking = async (provider: Client, network: NetworkNumber, market: LiquityV2Versions, user: EthAddress) => {
+export const getLiquityV2Staking = async (provider: Client, network: NetworkNumber, market: LiquityV2Versions, user: EthAddress): Promise<LiquityV2StakingData> => {
   const stabilityPoolView = createViemContractFromConfigFunc('LiquityV2StabilityPool', stabilityPoolAddrForMarket[market])(provider, network);
   const activePoolView = createViemContractFromConfigFunc('LiquityV2ActivePool', activePoolAddrForMarket[market])(provider, network);
 
@@ -638,7 +664,7 @@ export const getLiquityV2Staking = async (provider: Client, network: NetworkNumb
   };
 };
 
-export const getLiquitySAndYBold = async (provider: Client, network: NetworkNumber, markets: any, user: EthAddress) => {
+export const getLiquitySAndYBold = async (provider: Client, network: NetworkNumber, markets: any, user: EthAddress): Promise<LiquityV2SBoldYBoldData> => {
   const sBold = LiquityV2sBoldVaultViem(provider, network);
   const yBold = createViemContractFromConfigFunc('Erc4626', '0x9F4330700a36B29952869fac9b33f45EEdd8A3d8')(provider, network);
   const stYBold = createViemContractFromConfigFunc('Erc4626', '0x23346B04a7f55b8760E5860AA5A77383D63491cD')(provider, network);

package/src/maker/index.ts

@@ -1,19 +1,22 @@
 import Dec from 'decimal.js';
 import {
-  assetAmountInEth, bytesToString, getAssetInfo, ilkToAsset,
+  assetAmountInEth, bytesToString, getAssetInfo, ilkToAsset, stringToBytes,
 } from '@defisaver/tokens';
 import { Client, PublicClient } from 'viem';
 import {
-  Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, HexString, NetworkNumber, PositionBalances,
 } from '../types/common';
 import {
   getConfigContractAddress, McdDogContractViem, McdGetCdpsContractViem, McdJugContractViem, McdSpotterContractViem, McdVatContractViem, McdViewContractViem,
 } from '../contracts';
-import { CdpData, CdpInfo, CdpType } from '../types';
+import {
+  CdpData, CdpInfo, CdpType, IlkInfo,
+} from '../types';
 import { wethToEth } from '../services/utils';
 import { parseCollateralInfo } from '../helpers/makerHelpers';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
-import { getExposure } from '../moneymarket';
+import { getExposure, getSafetyRatioFromCollateralRatio } from '../moneymarket';
+import { calculateNetApyFromRates, getStakingApy, STAKING_ASSETS } from '../staking';
 
 export const _getMakerAccountBalances = async (provider: PublicClient, network: NetworkNumber, block: Blockish, addressMapping: boolean, cdpId: string, _managerAddress?: EthAddress): Promise<PositionBalances> => {
   let balances: PositionBalances = {
@@ -48,7 +51,7 @@ export const _getMakerAccountBalances = async (provider: PublicClient, network:
   const [
     par,
     [_, mat],
-    [artGlobal, rate, spot, line],
+    [artGlobal, rate, spot, line, dust],
     [duty],
     futureRate,
     chop,
@@ -69,6 +72,7 @@ export const _getMakerAccountBalances = async (provider: PublicClient, network:
     rate.toString(),
     spot.toString(),
     line.toString(),
+    dust.toString(),
     duty.toString(),
     futureRate.toString(),
     chop.toString(),
@@ -129,44 +133,73 @@ export const getUserCdps = async (
   userAddress: EthAddress,
 ): Promise<CdpInfo[]> => _getUserCdps(getViemProvider(provider, network), network, userAddress);
 
-export const _getMakerCdpData = async (provider: Client, network: NetworkNumber, cdp: CdpInfo): Promise<CdpData> => {
+export const _getMakerIlksData = async (provider: Client, network: NetworkNumber, ilkLabels: string[]): Promise<Record<string, IlkInfo>> => {
   const vatContract = McdVatContractViem(provider, network);
   const spotterContract = McdSpotterContractViem(provider, network);
   const dogContract = McdDogContractViem(provider, network);
   const jugContract = McdJugContractViem(provider, network);
 
+  const par = await spotterContract.read.par();
+
+  const ilksInfo = await Promise.all(ilkLabels.map(async (ilkLabel) => {
+    const ilk = stringToBytes(ilkLabel) as HexString;
+    const [
+      [_, mat],
+      [artGlobal, rate, spot, line, dust],
+      [duty],
+      futureRate,
+      chop,
+    ] = await Promise.all([
+      spotterContract.read.ilks([ilk]),
+      vatContract.read.ilks([ilk]),
+      jugContract.read.ilks([ilk]),
+      jugContract.read.drip([ilk]),
+      dogContract.read.chop([ilk]),
+    ]);
+
+    return parseCollateralInfo(
+      ilk,
+      par.toString(),
+      mat.toString(),
+      artGlobal.toString(),
+      rate.toString(),
+      spot.toString(),
+      line.toString(),
+      dust.toString(),
+      duty.toString(),
+      futureRate.toString(),
+      chop.toString(),
+    );
+  }));
+
+  return Object.fromEntries(ilksInfo.map((ilkInfo) => [ilkInfo.ilkLabel, ilkInfo]));
+};
+
+export const getMakerIlksData = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  ilkLabels: string[],
+): Promise<Record<string, IlkInfo>> => _getMakerIlksData(getViemProvider(provider, network, { batch: { multicall: true } }), network, ilkLabels);
+
+/**
+ * @param ilkInfo optional precomputed ilk data (from `_getMakerIlksData`); when provided the per-ilk reads are skipped
+ */
+export const _getMakerCdpData = async (provider: Client, network: NetworkNumber, cdp: CdpInfo, ilkInfo?: IlkInfo): Promise<CdpData> => {
+  const vatContract = McdVatContractViem(provider, network);
+
   const [
     [ink, art],
     coll,
-    par,
-    [_, mat],
-    [artGlobal, rate, spot, line],
-    [duty],
-    futureRate,
-    chop,
+    fetchedIlkInfo,
+    collStakingApy,
   ] = await Promise.all([
     vatContract.read.urns([cdp.ilk, cdp.urn]),
     vatContract.read.gem([cdp.ilk, cdp.urn]),
-    spotterContract.read.par(),
-    spotterContract.read.ilks([cdp.ilk]),
-    vatContract.read.ilks([cdp.ilk]),
-    jugContract.read.ilks([cdp.ilk]),
-    jugContract.read.drip([cdp.ilk]),
-    dogContract.read.chop([cdp.ilk]),
+    ilkInfo || _getMakerIlksData(provider, network, [cdp.ilkLabel]).then((ilks) => ilks[cdp.ilkLabel]),
+    STAKING_ASSETS.includes(cdp.asset) ? getStakingApy(cdp.asset) : Promise.resolve('0'),
   ]);
 
-  const collInfo = parseCollateralInfo(
-    cdp.ilk,
-    par.toString(),
-    mat.toString(),
-    artGlobal.toString(),
-    rate.toString(),
-    spot.toString(),
-    line.toString(),
-    duty.toString(),
-    futureRate.toString(),
-    chop.toString(),
-  );
+  const collInfo = fetchedIlkInfo;
 
   const collateral = assetAmountInEth(ink.toString(), `MCD-${cdp.asset}`);
 
@@ -180,9 +213,19 @@ export const _getMakerCdpData = async (provider: Client, network: NetworkNumber,
   let ratio = new Dec(ink).times(collInfo.assetPrice).div(debt).times(100)
     .toString();
   if (new Dec(debt).eq(0)) ratio = '0';
+  const safetyRatio = getSafetyRatioFromCollateralRatio(ratio, collInfo.liqPercent);
 
   const debtTooLow = new Dec(debt).gt(0) && new Dec(assetAmountInEth(debt, 'DAI')).lt(collInfo.minDebt);
 
+  // DAI debt accrues the ilk's stability fee. Collateral earns nothing inside the vault, except for the
+  // native yield of staked collateral (e.g. wstETH), which is tracked as an incentive.
+  const { netApy, totalInterestUsd, incentiveUsd } = calculateNetApyFromRates({
+    suppliedUsd: collateralUsd,
+    borrowedUsd: assetAmountInEth(debt, 'DAI'),
+    borrowRate: collInfo.stabilityFee.toString(),
+    incentives: [{ apy: collStakingApy, amountUsd: collateralUsd }],
+  });
+
   return {
     owner: cdp.owner,
     id: cdp.id.toString(),
@@ -201,6 +244,7 @@ export const _getMakerCdpData = async (provider: Client, network: NetworkNumber,
     debtAssetMarketPrice: '1',
     liquidationPrice,
     ratio,
+    safetyRatio,
     liqRatio: collInfo.liqRatio.toString(),
     liqPercent: parseFloat(collInfo.liqPercent.toString()),
     assetPrice: collInfo.assetPrice,
@@ -216,6 +260,9 @@ export const _getMakerCdpData = async (provider: Client, network: NetworkNumber,
     liquidationFee: collInfo.liquidationFee,
     lastUpdated: Date.now(),
     exposure: getExposure(assetAmountInEth(debt, 'DAI'), collateralUsd),
+    netApy,
+    totalInterestUsd,
+    incentiveUsd,
   };
 };
 

package/src/markets/index.ts

@@ -30,4 +30,5 @@ export {
   getFTokenAddress,
   getFluidMarketInfoByAddress,
 } from './fluid';
-export { AaveV4Spokes, findAaveV4SpokeByAddress } from './aaveV4';
+export { AaveV4Spokes, findAaveV4SpokeByAddress } from './aaveV4';
+export { MakerActiveIlks } from './maker';

package/src/markets/maker/index.ts

@@ -0,0 +1,10 @@
+export const MakerActiveIlks: string[] = [
+  'ETH-A',
+  'ETH-B',
+  'ETH-C',
+  'WSTETH-A',
+  'WSTETH-B',
+  'WBTC-A',
+  'WBTC-B',
+  'WBTC-C',
+];

package/src/moneymarket/moneymarketCommonService.ts

@@ -92,3 +92,18 @@ export const getExposure = (borrowedUsd: string, suppliedUsd: string) => {
   const balanceUsd = new Dec(suppliedUsd).sub(borrowedUsd).toString();
   return new Dec(suppliedUsd).div(balanceUsd).toDecimalPlaces(2).toString();
 };
+
+/**
+ * A collateral ratio rebased so that 100 means "sitting exactly on the liquidation ratio": the scale the
+ * shared `safetyRatio` field assumes. Protocols that liquidate on a raw collateral ratio (Maker at the ilk's
+ * liquidation ratio, Liquity at 110%, crvUSD/LlamaLend at the band-derived minimum) pass through here.
+ *
+ * Yields '0' when the liquidation ratio isn't available (or is 0), the "no signal" value consumers already recognise.
+ * Mirrors `getSafetyRatioFromCollateralRatio` on the client.
+ */
+export const getSafetyRatioFromCollateralRatio = (
+  collateralRatio: string | number | undefined,
+  liquidationRatio: string | number | undefined,
+): string => (+(liquidationRatio ?? 0) > 0
+  ? new Dec(collateralRatio || 0).div(liquidationRatio!).mul(100).toString()
+  : '0');