@defisaver/positions-sdk 0.0.199 → 0.0.201-fluid-dev

package/esm/fluid/index.d.ts

@@ -0,0 +1,38 @@
+import Web3 from 'web3';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { FluidAssetsData, FluidMarketData, FluidMarketInfo, FluidVaultData, InnerFluidMarketData } from '../types';
+export declare const EMPTY_USED_ASSET: {
+    isSupplied: boolean;
+    isBorrowed: boolean;
+    supplied: string;
+    suppliedUsd: string;
+    borrowed: string;
+    borrowedUsd: string;
+    symbol: string;
+    collateral: boolean;
+};
+export declare const EMPTY_FLUID_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    isSubscribedToAutomation: boolean;
+    automationResubscribeRequired: boolean;
+    lastUpdated: number;
+};
+export declare const getFluidMarketData: (web3: Web3, network: NetworkNumber, market: FluidMarketInfo) => Promise<FluidMarketData>;
+export declare const getFluidVaultIdsForUser: (web3: Web3, network: NetworkNumber, user: EthAddress) => Promise<string[]>;
+export declare const getFluidPosition: (web3: Web3, network: NetworkNumber, vaultId: string, extractedState: {
+    assetsData: FluidAssetsData;
+    marketData: InnerFluidMarketData;
+}) => Promise<FluidVaultData>;
+export declare const getFluidPositionWithMarket: (web3: Web3, network: NetworkNumber, vaultId: string) => Promise<{
+    userData: FluidVaultData;
+    marketData: FluidMarketData;
+}>;

package/esm/fluid/index.js

@@ -0,0 +1,153 @@
+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 { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { FluidVaultType, } from '../types';
+import { FluidViewContract } from '../contracts';
+import { getEthAmountForDecimals } from '../services/utils';
+import { getFluidAggregatedData } from '../helpers/fluidHelpers';
+export const EMPTY_USED_ASSET = {
+    isSupplied: false,
+    isBorrowed: false,
+    supplied: '0',
+    suppliedUsd: '0',
+    borrowed: '0',
+    borrowedUsd: '0',
+    symbol: '',
+    collateral: false,
+};
+const parseVaultType = (vaultType) => {
+    switch (vaultType) {
+        case 10000: return FluidVaultType.T1;
+        case 20000: return FluidVaultType.T2;
+        case 30000: return FluidVaultType.T3;
+        case 40000: return FluidVaultType.T4;
+        default: return FluidVaultType.Unknown;
+    }
+};
+const parseMarketData = (data) => {
+    const collAsset = getAssetInfoByAddress(data.supplyToken0);
+    const debtAsset = getAssetInfoByAddress(data.borrowToken0);
+    const collAssetData = {
+        symbol: collAsset.symbol,
+        address: collAsset.address,
+        price: getEthAmountForDecimals(data.priceOfSupplyToken0InUSD, 8),
+        totalSupply: data.totalSupplyVault,
+        totalBorrow: data.totalBorrowVault,
+        canBeSupplied: true,
+        canBeBorrowed: false,
+        supplyRate: new Dec(data.supplyRateVault).div(100).toString(),
+        borrowRate: '0',
+    };
+    const debtAssetData = {
+        symbol: debtAsset.symbol,
+        address: debtAsset.address,
+        price: getEthAmountForDecimals(data.priceOfBorrowToken0InUSD, 8),
+        totalSupply: data.totalSupplyVault,
+        totalBorrow: data.totalBorrowVault,
+        canBeSupplied: false,
+        canBeBorrowed: true,
+        supplyRate: '0',
+        borrowRate: new Dec(data.borrowRateVault).div(100).toString(),
+    };
+    const assetsData = {
+        [collAsset.symbol]: collAssetData,
+        [debtAsset.symbol]: debtAssetData,
+    };
+    const marketData = {
+        vaultId: +data.vaultId,
+        isSmartColl: data.isSmartColl,
+        isSmartDebt: data.isSmartDebt,
+        marketAddress: data.vault,
+        vaultType: parseVaultType(+data.vaultType),
+        oracle: data.oracle,
+        liquidationPenaltyPercent: new Dec(data.liquidationPenalty).div(100).toString(),
+        collFactor: new Dec(data.collateralFactor).div(10000).toString(),
+        liquidationRatio: new Dec(data.liquidationThreshold).div(100).toString(),
+        collAsset0: collAsset.symbol,
+        debtAsset0: debtAsset.symbol,
+        totalPositions: data.totalPositions,
+        totalSupplyVault: getEthAmountForDecimals(data.totalSupplyVault, collAsset.decimals),
+        totalBorrowVault: getEthAmountForDecimals(data.totalBorrowVault, debtAsset.decimals),
+        withdrawalLimit: getEthAmountForDecimals(data.withdrawalLimit, collAsset.decimals),
+        withdrawableUntilLimit: getEthAmountForDecimals(data.withdrawableUntilLimit, collAsset.decimals),
+        withdrawable: getEthAmountForDecimals(data.withdrawable, collAsset.decimals),
+        borrowLimit: getEthAmountForDecimals(data.borrowLimit, debtAsset.decimals),
+        borrowableUntilLimit: getEthAmountForDecimals(data.borrowableUntilLimit, debtAsset.decimals),
+        borrowable: getEthAmountForDecimals(data.borrowable, debtAsset.decimals),
+        borrowLimitUtilization: getEthAmountForDecimals(data.borrowLimitUtilization, debtAsset.decimals),
+        maxBorrowLimit: getEthAmountForDecimals(data.maxBorrowLimit, debtAsset.decimals),
+        baseBorrowLimit: getEthAmountForDecimals(data.baseBorrowLimit, debtAsset.decimals),
+        minimumBorrowing: getEthAmountForDecimals(data.minimumBorrowing, debtAsset.decimals),
+    };
+    return {
+        assetsData,
+        marketData,
+    };
+};
+export const EMPTY_FLUID_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    isSubscribedToAutomation: false,
+    automationResubscribeRequired: false,
+    lastUpdated: Date.now(),
+};
+const parseUserData = (userPositionData, vaultData) => {
+    const { assetsData, marketData, } = vaultData;
+    const payload = Object.assign(Object.assign({ owner: userPositionData.owner, vaultId: marketData.vaultId }, EMPTY_FLUID_DATA), { lastUpdated: Date.now() });
+    const collAsset = getAssetInfo(marketData.collAsset0);
+    const debtAsset = getAssetInfo(marketData.debtAsset0);
+    const supplied = getEthAmountForDecimals(userPositionData.supply, collAsset.decimals);
+    const borrowed = getEthAmountForDecimals(userPositionData.borrow, debtAsset.decimals);
+    const collUsedAsset = Object.assign(Object.assign({}, EMPTY_USED_ASSET), { symbol: collAsset.symbol, collateral: true, supplied, suppliedUsd: new Dec(supplied).mul(assetsData[collAsset.symbol].price).toString(), isSupplied: new Dec(supplied).gt(0) });
+    const debtUsedAsset = Object.assign(Object.assign({}, EMPTY_USED_ASSET), { symbol: debtAsset.symbol, collateral: false, borrowed, borrowedUsd: new Dec(borrowed).mul(assetsData[debtAsset.symbol].price).toString(), isBorrowed: new Dec(borrowed).gt(0) });
+    const usedAssets = {
+        [collAsset.symbol]: collUsedAsset,
+        [debtAsset.symbol]: debtUsedAsset,
+    };
+    return Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), getFluidAggregatedData({
+        usedAssets,
+        assetsData,
+        marketData,
+    }));
+};
+export const getFluidMarketData = (web3, network, market) => __awaiter(void 0, void 0, void 0, function* () {
+    const view = FluidViewContract(web3, network);
+    const data = yield view.methods.getVaultData(market.marketAddress).call();
+    return parseMarketData(data);
+});
+export const getFluidVaultIdsForUser = (web3, network, user) => __awaiter(void 0, void 0, void 0, function* () {
+    const view = FluidViewContract(web3, network);
+    return view.methods.getUserNftIds(user).call();
+});
+export const getFluidPosition = (web3, network, vaultId, extractedState) => __awaiter(void 0, void 0, void 0, function* () {
+    const view = FluidViewContract(web3, network);
+    const data = yield view.methods.getPositionByNftId(vaultId).call();
+    const userPositionData = data[0];
+    return parseUserData(userPositionData, extractedState);
+});
+export const getFluidPositionWithMarket = (web3, network, vaultId) => __awaiter(void 0, void 0, void 0, function* () {
+    const view = FluidViewContract(web3, network);
+    const data = yield view.methods.getPositionByNftId(vaultId).call();
+    const marketData = parseMarketData(data.vault);
+    const userData = parseUserData(data.position, marketData);
+    return {
+        userData,
+        marketData,
+    };
+});

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

@@ -0,0 +1,6 @@
+import { FluidAggregatedVaultData, FluidAssetsData, FluidUsedAssets, InnerFluidMarketData } from '../../types';
+export declare const getFluidAggregatedData: ({ usedAssets, assetsData, marketData, }: {
+    usedAssets: FluidUsedAssets;
+    marketData: InnerFluidMarketData;
+    assetsData: FluidAssetsData;
+}) => FluidAggregatedVaultData;

package/esm/helpers/fluidHelpers/index.js

@@ -0,0 +1,33 @@
+import Dec from 'decimal.js';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+export const getFluidAggregatedData = ({ usedAssets, assetsData, marketData, }) => {
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({ usedAssets, assetsData: assetsData });
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    const collFactor = marketData.collFactor;
+    const liqRatio = marketData.liquidationRatio;
+    payload.borrowLimitUsd = new Dec(payload.suppliedUsd).mul(collFactor).toString();
+    payload.liquidationLimitUsd = new Dec(payload.suppliedUsd).mul(liqRatio).div(100).toString();
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        let assetPrice = assetsData[leveragedAsset].price;
+        if (leveragedType === 'lsd-leverage') {
+            // Treat ETH like a stablecoin in a long stETH position
+            payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedAsset].price).div(assetsData.ETH.price).toDP(18).toString();
+            assetPrice = new Dec(assetPrice).div(assetsData.ETH.price).toString();
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    return payload;
+};

package/esm/helpers/index.d.ts

@@ -6,4 +6,6 @@ export * as makerHelpers from './makerHelpers';
 export * as chickenBondsHelpers from './chickenBondsHelpers';
 export * as morphoBlueHelpers from './morphoBlueHelpers';
 export * as llamaLendHelpers from './llamaLendHelpers';
+export * as liquityV2Helpers from './liquityV2Helpers';
 export * as eulerV2Helpers from './eulerHelpers';
+export * as fluidHelpers from './fluidHelpers';

package/esm/helpers/index.js

@@ -6,4 +6,6 @@ export * as makerHelpers from './makerHelpers';
 export * as chickenBondsHelpers from './chickenBondsHelpers';
 export * as morphoBlueHelpers from './morphoBlueHelpers';
 export * as llamaLendHelpers from './llamaLendHelpers';
+export * as liquityV2Helpers from './liquityV2Helpers';
 export * as eulerV2Helpers from './eulerHelpers';
+export * as fluidHelpers from './fluidHelpers';

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

@@ -0,0 +1,12 @@
+import { LiquityV2AggregatedTroveData, LiquityV2AssetsData, LiquityV2UsedAssets } from '../../types';
+export declare const calculateNetApyLiquityV2: (usedAssets: LiquityV2UsedAssets, assetsData: LiquityV2AssetsData, interestRate: string) => {
+    netApy: string;
+    totalInterestUsd: string;
+    incentiveUsd: string;
+};
+export declare const getLiquityV2AggregatedPositionData: ({ usedAssets, assetsData, minCollRatio, interestRate, }: {
+    usedAssets: LiquityV2UsedAssets;
+    assetsData: LiquityV2AssetsData;
+    minCollRatio: string;
+    interestRate: string;
+}) => LiquityV2AggregatedTroveData;

package/esm/helpers/liquityV2Helpers/index.js

@@ -0,0 +1,55 @@
+import Dec from 'decimal.js';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateInterestEarned } from '../../staking';
+export const calculateNetApyLiquityV2 = (usedAssets, assetsData, interestRate) => {
+    const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
+        const acc = Object.assign({}, _acc);
+        const assetData = assetsData[usedAsset.symbol];
+        if (usedAsset.suppliedUsd) {
+            const amount = usedAsset.suppliedUsd;
+            acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
+            if (assetData.incentiveSupplyApy) {
+                const incentiveInterest = calculateInterestEarned(amount, assetData.incentiveSupplyApy, 'year', true);
+                acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
+            }
+        }
+        if (usedAsset.borrowedUsd) {
+            const amount = usedAsset.borrowedUsd;
+            acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
+            const rate = interestRate;
+            const borrowInterest = calculateInterestEarned(amount, rate, 'year', true);
+            acc.borrowInterest = new Dec(acc.borrowInterest).sub(borrowInterest.toString()).toString();
+        }
+        return acc;
+    }, {
+        borrowInterest: '0', supplyInterest: '0', incentiveUsd: '0', borrowedUsd: '0', suppliedUsd: '0',
+    });
+    const { borrowedUsd, suppliedUsd, borrowInterest, supplyInterest, incentiveUsd, } = sumValues;
+    const totalInterestUsd = new Dec(borrowInterest).add(supplyInterest).add(incentiveUsd).toString();
+    const balance = new Dec(suppliedUsd).sub(borrowedUsd);
+    const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
+    return { netApy, totalInterestUsd, incentiveUsd };
+};
+export const getLiquityV2AggregatedPositionData = ({ usedAssets, assetsData, minCollRatio, interestRate, }) => {
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, (usedAsset) => usedAsset, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, (usedAsset) => usedAsset, ({ borrowedUsd }) => borrowedUsd);
+    payload.borrowLimitUsd = new Dec(payload.suppliedUsd).div(minCollRatio).mul(100).toString();
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApyLiquityV2(usedAssets, assetsData, interestRate);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    payload.leveragedAsset = leveragedAsset;
+    payload.liquidationPrice = '';
+    if (leveragedType !== '') {
+        const assetPrice = assetsData[leveragedAsset].price;
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.borrowLimitUsd);
+    }
+    return payload;
+};

package/esm/index.d.ts

@@ -1,4 +1,5 @@
 import './setup';
+import * as fluid from './fluid';
 import * as aaveV3 from './aaveV3';
 import * as morphoAaveV3 from './morphoAaveV3';
 import * as aaveV2 from './aaveV2';
@@ -8,6 +9,7 @@ import * as compoundV2 from './compoundV2';
 import * as spark from './spark';
 import * as curveUsd from './curveUsd';
 import * as liquity from './liquity';
+import * as liquityV2 from './liquityV2';
 import * as maker from './maker';
 import * as staking from './staking';
 import * as multicall from './multicall';
@@ -20,4 +22,4 @@ import * as morphoBlue from './morphoBlue';
 import * as llamaLend from './llamaLend';
 import * as eulerV2 from './eulerV2';
 export * from './types';
-export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, };
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, };

package/esm/index.js

@@ -1,4 +1,5 @@
 import './setup';
+import * as fluid from './fluid';
 import * as aaveV3 from './aaveV3';
 import * as morphoAaveV3 from './morphoAaveV3';
 import * as aaveV2 from './aaveV2';
@@ -8,6 +9,7 @@ import * as compoundV2 from './compoundV2';
 import * as spark from './spark';
 import * as curveUsd from './curveUsd';
 import * as liquity from './liquity';
+import * as liquityV2 from './liquityV2';
 import * as maker from './maker';
 import * as staking from './staking';
 import * as multicall from './multicall';
@@ -20,4 +22,4 @@ import * as morphoBlue from './morphoBlue';
 import * as llamaLend from './llamaLend';
 import * as eulerV2 from './eulerV2';
 export * from './types';
-export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, };
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, liquityV2, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, fluid, };

package/esm/liquityV2/index.d.ts

@@ -0,0 +1,18 @@
+import Web3 from 'web3';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { InnerLiquityV2MarketData, LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2TroveData } from '../types';
+export declare const getLiquityV2MarketData: (web3: Web3, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, mainnetWeb3: Web3) => Promise<LiquityV2MarketData>;
+export declare const getLiquityV2UserTroveIds: (web3: Web3, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress) => Promise<{
+    troves: {
+        troveId: string;
+    }[];
+    nextFreeTroveIndex: string;
+}>;
+export declare const getDebtInFrontLiquityV2: (viewContract: any, marketAddress: EthAddress, troveId: string, accumulatedSum?: string, iterations?: number) => Promise<string>;
+export declare const getLiquityV2TroveData: (web3: Web3, network: NetworkNumber, { selectedMarket, assetsData, marketData, troveId, }: {
+    selectedMarket: LiquityV2MarketInfo;
+    assetsData: LiquityV2AssetsData;
+    marketData: InnerLiquityV2MarketData;
+    troveId: string;
+}) => Promise<LiquityV2TroveData>;
+export declare const getLiquityV2ClaimableCollateral: (collSurplusPoolAddress: EthAddress, account: EthAddress, web3: Web3, network: NetworkNumber) => Promise<string>;

package/esm/liquityV2/index.js

@@ -0,0 +1,183 @@
+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, getAssetInfo } from '@defisaver/tokens';
+import { createContractWrapper, LiquityV2ViewContract } from '../contracts';
+import { LIQUITY_V2_TROVE_STATUS_ENUM, } from '../types';
+import { getStakingApy, STAKING_ASSETS } from '../staking';
+import { getLiquityV2AggregatedPositionData } from '../helpers/liquityV2Helpers';
+import { compareAddresses, ethToWeth } from '../services/utils';
+import { ZERO_ADDRESS } from '../constants';
+export const getLiquityV2MarketData = (web3, network, selectedMarket, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const { marketAddress, debtToken, collateralToken } = selectedMarket;
+    const data = yield viewContract.methods.getMarketData(marketAddress).call();
+    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();
+    const totalMarketBorrow = assetAmountInEth(data.entireSystemDebt);
+    const totalMarketSupply = assetAmountInEth(data.entireSystemColl);
+    const collPrice = assetAmountInEth(data.collPrice);
+    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 = {};
+    assetsData[debtToken] = {
+        symbol: debtToken,
+        address: getAssetInfo(debtToken, network).address,
+        price: '1',
+        totalSupply: '0',
+        totalBorrow: totalMarketBorrow,
+        canBeSupplied: false,
+        canBeBorrowed: true,
+        leftToBorrowGlobal,
+        leftToWithdrawGlobal: '0',
+    };
+    assetsData[collateralToken] = {
+        symbol: collateralToken,
+        address: getAssetInfo(ethToWeth(collateralToken), network).address,
+        price: collPrice,
+        totalSupply: totalMarketSupply,
+        totalBorrow: '0',
+        canBeSupplied: true,
+        canBeBorrowed: false,
+        leftToBorrowGlobal: '0',
+        leftToWithdrawGlobal,
+    };
+    if (STAKING_ASSETS.includes(collateralToken)) {
+        assetsData[collateralToken].incentiveSupplyApy = yield getStakingApy(collateralToken, mainnetWeb3);
+        assetsData[collateralToken].incentiveSupplyToken = collateralToken;
+    }
+    return {
+        assetsData,
+        marketData: {
+            minCollRatio,
+            totalCollRatio: new Dec(totalCollRatio).mul(100).toString(),
+            criticalCollRatio: new Dec(criticalCollRatio).mul(100).toString(),
+            isUnderCollateralized: new Dec(totalCollRatio).lt(criticalCollRatio),
+            hintHelperAddress,
+            troveNFTAddress,
+            borrowerOperationsAddress,
+            troveManagerAddress,
+            stabilityPoolAddress,
+            collSurplusPoolAddress,
+            activePoolAddress,
+        },
+    };
+});
+const _getUserTroves = (viewContract, account, marketAddress, startIndex = 0, endIndex = 100) => __awaiter(void 0, void 0, void 0, function* () { return viewContract.methods.getUserTroves(account, marketAddress, startIndex, endIndex).call(); });
+const getUserTroves = (viewContract, account, marketAddress, startIndex = 0, endIndex = 100, troves = []) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield _getUserTroves(viewContract, account, marketAddress, startIndex, endIndex);
+    const newStartIndex = endIndex + 1;
+    const nextFreeTroveIndex = result.nextFreeTroveIndex;
+    const existingTroves = [...troves, ...result.troves];
+    if (nextFreeTroveIndex !== '-1')
+        return { troves: existingTroves.filter((trove) => trove.ownedByUser), nextFreeTroveIndex };
+    return getUserTroves(viewContract, account, marketAddress, newStartIndex, newStartIndex + 100, existingTroves);
+});
+const TransferEventSig = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+const nftContractCreationBlockMapping = {
+    ETH: 21686215,
+    wstETH: 21686238,
+    rETH: 21686257,
+};
+const getTransferredTroves = (web3, network, troveNFTAddress, limitBlocksForEventFetching, collAsset, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const nftContract = createContractWrapper(web3, network, 'LiquityV2TroveNFT', troveNFTAddress);
+    // @ts-ignore
+    const nftContractCreationBlock = nftContractCreationBlockMapping[collAsset];
+    const currentBlock = yield web3.eth.getBlockNumber();
+    const events = yield nftContract.getPastEvents(TransferEventSig, {
+        filter: { to: account },
+        fromBlock: limitBlocksForEventFetching ? (currentBlock - 1000) : nftContractCreationBlock,
+    });
+    const userTransferredTroves = events.filter((event) => !compareAddresses(event.returnValues.from, ZERO_ADDRESS) && compareAddresses(event.returnValues.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.returnValues.tokenId === event.returnValues.tokenId);
+        // @ts-ignore
+        userTransferredTroves[index].invalid = !!otherTransfers.length;
+    });
+    // @ts-ignore
+    return userTransferredTroves.filter((event) => !event.invalid).map((event) => ({ troveId: event.returnValues.tokenId }));
+});
+export const getLiquityV2UserTroveIds = (web3, network, selectedMarket, troveNFTAddress, limitBlocksForEventFetching, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const [{ troves: userTroves, nextFreeTroveIndex }, userTransferredTroves] = yield Promise.all([
+        getUserTroves(viewContract, account, selectedMarket.marketAddress),
+        getTransferredTroves(web3, network, troveNFTAddress, limitBlocksForEventFetching, selectedMarket.collateralToken, account),
+    ]);
+    const troves = [...userTroves.map(({ troveId }) => ({ troveId })), ...userTransferredTroves];
+    const filteredTroves = troves.filter((value, index, self) => index === self.findIndex((t) => (t.troveId === value.troveId)));
+    return { troves: filteredTroves, nextFreeTroveIndex };
+});
+const _getDebtInFront = (viewContract, marketAddress, troveId, accumulatedSum = '0', iterations = 2000) => __awaiter(void 0, void 0, void 0, function* () { return viewContract.methods.getDebtInFront(marketAddress, troveId, accumulatedSum, iterations).call(); });
+export const getDebtInFrontLiquityV2 = (viewContract, marketAddress, troveId, accumulatedSum = '0', iterations = 2000) => __awaiter(void 0, void 0, void 0, function* () {
+    const { debt, next } = yield _getDebtInFront(viewContract, marketAddress, troveId, accumulatedSum, iterations);
+    if (next === '0')
+        return assetAmountInEth(debt);
+    return getDebtInFrontLiquityV2(viewContract, marketAddress, next, debt, iterations);
+});
+export const getLiquityV2TroveData = (web3, network, { selectedMarket, assetsData, marketData, troveId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const { minCollRatio } = marketData;
+    const { collateralToken, marketAddress, debtToken } = selectedMarket;
+    const [data, debtInFront] = yield Promise.all([
+        viewContract.methods.getTroveInfo(marketAddress, troveId).call(),
+        getDebtInFrontLiquityV2(viewContract, marketAddress, troveId),
+    ]);
+    const usedAssets = {};
+    const debtAssetData = assetsData[debtToken];
+    const borrowed = assetAmountInEth(data.debtAmount);
+    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);
+    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 payload = Object.assign(Object.assign({ usedAssets,
+        troveId,
+        interestRate,
+        interestBatchManager,
+        debtInFront, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status, 10)] }, getLiquityV2AggregatedPositionData({
+        usedAssets, assetsData, minCollRatio, interestRate,
+    })), { collRatio });
+    return payload;
+});
+export const getLiquityV2ClaimableCollateral = (collSurplusPoolAddress, account, web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const collSurplusPoolContract = createContractWrapper(web3, network, 'LiquityV2CollSurplusPool', collSurplusPoolAddress);
+    const claimableCollateral = yield collSurplusPoolContract.methods.getCollateral(account).call();
+    return claimableCollateral;
+});

package/esm/markets/aave/marketAssets.js

@@ -7,7 +7,7 @@ export const aaveV1AssetsDefaultMarket = [
 export const aaveV2AssetsDefaultMarket = ['USDT', 'WBTC', 'ETH', 'YFI', 'ZRX', 'UNI', 'AAVE', 'BAT', 'BUSD', 'DAI', 'ENJ', 'KNCL', 'LINK', 'MANA', 'MKR', 'REN', 'SNX', 'SUSD', 'TUSD', 'USDC', 'CRV', 'GUSD', 'BAL', 'xSUSHI', 'RENFIL', 'RAI', 'AMPL', 'USDP', 'DPI', 'FRAX', 'FEI', 'stETH', 'ENS', 'UST', 'CVX', '1INCH', 'LUSD'];
 export const morphoAaveV2AssetDefaultMarket = ['DAI', 'ETH', 'USDC', 'USDT', 'WBTC', 'stETH', 'CRV'];
 export const morphoAaveV3AssetEthMarket = ['ETH', 'wstETH', 'DAI', 'USDC', 'WBTC', 'rETH', 'cbETH', 'sDAI', 'USDT'];
-export const aaveV3AssetsDefaultMarketEth = ['ETH', 'wstETH', 'WBTC', 'USDC', 'DAI', 'LINK', 'AAVE', 'cbETH', 'USDT', 'rETH', 'LUSD', 'CRV', 'MKR', 'SNX', 'BAL', 'UNI', 'LDO', 'ENS', '1INCH', 'FRAX', 'GHO', 'RPL', 'sDAI', 'STG', 'KNC', 'FXS', 'crvUSD', 'PYUSD', 'weETH', 'osETH', 'USDe', 'ETHx', 'sUSDe', 'tBTC', 'cbBTC', 'USDS', 'rsETH'];
+export const aaveV3AssetsDefaultMarketEth = ['ETH', 'wstETH', 'WBTC', 'USDC', 'DAI', 'LINK', 'AAVE', 'cbETH', 'USDT', 'rETH', 'LUSD', 'CRV', 'MKR', 'SNX', 'BAL', 'UNI', 'LDO', 'ENS', '1INCH', 'FRAX', 'GHO', 'RPL', 'sDAI', 'STG', 'KNC', 'FXS', 'crvUSD', 'PYUSD', 'weETH', 'osETH', 'USDe', 'ETHx', 'sUSDe', 'tBTC', 'cbBTC', 'USDS', 'rsETH', 'LBTC'];
 export const aaveV3AssetsDefaultMarketOpt = [
     'DAI', 'USDC.e', 'USDT', 'SUSD', 'AAVE', 'LINK', 'WBTC', 'ETH', 'OP', 'wstETH', 'LUSD', 'MAI', 'rETH', 'USDC',
 ];