@defisaver/positions-sdk 0.0.1

package/cjs/assets/index.js

@@ -0,0 +1,54 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetsBalances = exports.getAssetBalance = void 0;
+const tokens_1 = require("@defisaver/tokens");
+const utils_1 = require("../services/utils");
+const contracts_1 = require("../contracts");
+const getAssetBalance = (asset, address, chainId, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        return '0';
+    // noinspection JSUnusedAssignment
+    let data = '';
+    const isAssetAddress = (0, utils_1.isAddress)(asset);
+    const network = chainId;
+    const isOptimism = network === 10;
+    if (!isOptimism
+        && (asset === 'ETH' || (0, utils_1.compareAddresses)(asset, '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'))) {
+        data = yield web3.eth.getBalance(address);
+    }
+    else {
+        let _asset = isAssetAddress ? asset : (0, tokens_1.getAssetInfo)(asset).address;
+        if (isOptimism && (0, utils_1.compareAddresses)(_asset, '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')) {
+            _asset = '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000';
+        }
+        const contract = yield (0, contracts_1.getErc20Contract)(_asset, web3);
+        data = (yield contract.methods.balanceOf(address).call()).toString();
+    }
+    return isAssetAddress
+        // @ts-ignore
+        ? getEthAmountForDecimals(data, (yield getERC20TokenData(asset)).decimals)
+        : (0, tokens_1.assetAmountInEth)(data, asset);
+});
+exports.getAssetBalance = getAssetBalance;
+const getAssetsBalances = (assets, address, networkId, web3) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = (0, contracts_1.BalanceScannerContract)(web3, networkId);
+    const balancesFromChain = [...yield contract.methods.tokensBalance(address, assets.map(a => (0, tokens_1.getAssetInfo)(a, networkId).address)).call()];
+    const balances = balancesFromChain.map((item, i) => (item.success
+        ? (0, tokens_1.assetAmountInEth)(web3.utils.hexToNumberString(item.data), assets[i])
+        : '0'));
+    const ethIndex = assets.indexOf('ETH');
+    if (ethIndex !== -1) {
+        balances[ethIndex] = yield (0, exports.getAssetBalance)('ETH', address, networkId, web3);
+    }
+    return balances;
+});
+exports.getAssetsBalances = getAssetsBalances;

package/cjs/chickenBonds/index.d.ts

@@ -0,0 +1,3 @@
+import Web3 from 'web3';
+import { Blockish, NetworkNumber, PositionBalances } from '../types/common';
+export declare const getChickenBondsAccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, bondId: string) => Promise<PositionBalances>;

package/cjs/chickenBonds/index.js

@@ -0,0 +1,24 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChickenBondsAccountBalances = void 0;
+const tokens_1 = require("@defisaver/tokens");
+const contracts_1 = require("../contracts");
+const getChickenBondsAccountBalances = (web3, network, block, addressMapping, bondId) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = (0, contracts_1.ChickenBondsViewContract)(web3, network, block);
+    const fullBondInfo = yield viewContract.methods.getBondFullInfo(bondId).call({}, block);
+    return {
+        deposited: {
+            [addressMapping ? (0, tokens_1.getAssetInfo)('LUSD', network).address.toLowerCase() : 'LUSD']: fullBondInfo.lusdAmount,
+        },
+    };
+});
+exports.getChickenBondsAccountBalances = getChickenBondsAccountBalances;

package/cjs/compoundV2/index.d.ts

@@ -0,0 +1,21 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { CompoundV2AssetsData, CompoundV2MarketsData, CompoundV2PositionData } from '../types';
+export declare const getCompoundV2MarketsData: (web3: Web3, network: NetworkNumber) => Promise<CompoundV2MarketsData>;
+export declare const EMPTY_COMPOUND_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    borrowStableSupplyUnstable: boolean;
+};
+export declare const getCollateralAssetsAddresses: (web3: Web3, network: NetworkNumber, account: string) => Promise<string[]>;
+export declare const getCompoundV2AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getCompoundV2AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: CompoundV2AssetsData) => Promise<CompoundV2PositionData>;
+export declare const getCompoundV2FullPositionData: (web3: Web3, network: NetworkNumber, address: string) => Promise<CompoundV2PositionData>;

package/cjs/compoundV2/index.js

@@ -0,0 +1,168 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompoundV2FullPositionData = exports.getCompoundV2AccountData = exports.getCompoundV2AccountBalances = exports.getCollateralAssetsAddresses = exports.EMPTY_COMPOUND_DATA = exports.getCompoundV2MarketsData = void 0;
+const tokens_1 = require("@defisaver/tokens");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const constants_1 = require("../constants");
+const moneymarket_1 = require("../moneymarket");
+const utils_1 = require("../services/utils");
+const contracts_1 = require("../contracts");
+const marketsAssets_1 = require("../markets/compound/marketsAssets");
+const compoundHelpers_1 = require("../helpers/compoundHelpers");
+const compAddress = '0xc00e94cb662c3520282e6f5717214004a7f26888';
+const getCompoundV2MarketsData = (web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const cAddresses = marketsAssets_1.compoundV2CollateralAssets.map(a => a.address);
+    const loanInfoContract = (0, contracts_1.CompoundLoanInfoContract)(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getFullTokensInfo(cAddresses).call();
+    const compPrice = loanInfo.find(m => (0, utils_1.compareAddresses)(m.underlyingTokenAddress, compAddress)).price.toString();
+    const assetsData = loanInfo
+        .map((market, i) => {
+        let symbol = (0, tokens_1.getAssetInfoByAddress)(cAddresses[i]).underlyingAsset;
+        let isWbtcLegacy = false;
+        const totalSupply = new decimal_js_1.default(market.totalSupply.toString()).div(1e18).times(market.exchangeRate.toString());
+        const totalBorrow = market.totalBorrow.toString();
+        const borrowCap = market.borrowCap.toString();
+        const compSupplySpeeds = market.compSupplySpeeds.toString();
+        const compBorrowSpeeds = market.compBorrowSpeeds.toString();
+        const assetPrice = market.price.toString();
+        const pricePrecisionDiff = 18 - (0, tokens_1.getAssetInfo)((0, tokens_1.getAssetInfoByAddress)(cAddresses[i]).underlyingAsset).decimals;
+        // compSupplySpeeds/compBorrowSpeeds is per block per market (borrow & supply are separate markets)
+        const incentiveSupplyApy = (0, moneymarket_1.aprToApy)((100 * constants_1.BLOCKS_IN_A_YEAR * +compSupplySpeeds * +compPrice) / +assetPrice / +totalSupply).toString();
+        const incentiveBorrowApy = (0, moneymarket_1.aprToApy)((100 * constants_1.BLOCKS_IN_A_YEAR * +compBorrowSpeeds * +compPrice) / +assetPrice / +totalBorrow).toString();
+        if (cAddresses[i].toLowerCase() === '0xc11b1268c1a384e55c48c2391d8d480264a3a7f4'.toLowerCase()) {
+            symbol = 'WBTC Legacy';
+            isWbtcLegacy = true;
+        }
+        return {
+            symbol,
+            underlyingTokenAddress: market.underlyingTokenAddress,
+            supplyRate: (0, moneymarket_1.aprToApy)(new decimal_js_1.default(constants_1.BLOCKS_IN_A_YEAR).times(market.supplyRate.toString()).div(1e16).toString()).toString(),
+            borrowRate: (0, moneymarket_1.aprToApy)(new decimal_js_1.default(constants_1.BLOCKS_IN_A_YEAR).times(market.borrowRate.toString()).div(1e16).toString()).toString(),
+            incentiveSupplyToken: 'COMP',
+            incentiveBorrowToken: 'COMP',
+            incentiveSupplyApy,
+            incentiveBorrowApy,
+            collateralFactor: new decimal_js_1.default(market.collateralFactor.toString()).div(1e18).toString(),
+            marketLiquidity: (0, tokens_1.assetAmountInEth)(market.marketLiquidity.toString(), (0, utils_1.handleWbtcLegacy)(symbol)),
+            utilization: new decimal_js_1.default(market.totalBorrow.toString()).div(totalSupply).times(100).toString(),
+            totalSupply: (0, tokens_1.assetAmountInEth)(totalSupply, (0, utils_1.handleWbtcLegacy)(symbol)),
+            totalBorrow: (0, tokens_1.assetAmountInEth)(totalBorrow, (0, utils_1.handleWbtcLegacy)(symbol)),
+            exchangeRate: new decimal_js_1.default(market.exchangeRate.toString()).div(1e28).toString(),
+            borrowCap: (0, tokens_1.assetAmountInEth)(borrowCap, (0, utils_1.handleWbtcLegacy)(symbol)),
+            canBeBorrowed: market.canBorrow,
+            canBeSupplied: market.canMint,
+            price: new decimal_js_1.default(market.price.toString()).div(Math.pow(10, (18 + pricePrecisionDiff))).toString(),
+        };
+    });
+    const payload = {};
+    // Sort by market size
+    assetsData
+        .sort((a, b) => {
+        const aMarket = new decimal_js_1.default(a.price).times(a.totalSupply).toString();
+        const bMarket = new decimal_js_1.default(b.price).times(b.totalSupply).toString();
+        return new decimal_js_1.default(bMarket).minus(aMarket).toNumber();
+    })
+        .forEach((market, i) => { payload[market.symbol] = Object.assign(Object.assign({}, market), { sortIndex: i }); });
+    return { assetsData: payload };
+});
+exports.getCompoundV2MarketsData = getCompoundV2MarketsData;
+exports.EMPTY_COMPOUND_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    borrowStableSupplyUnstable: false,
+};
+const getCollateralAssetsAddresses = (web3, network, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = (0, contracts_1.ComptrollerContract)(web3, network);
+    return contract.methods.getAssetsIn(account).call();
+});
+exports.getCollateralAssetsAddresses = getCollateralAssetsAddresses;
+const getCompoundV2AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const loanInfoContract = (0, contracts_1.CompoundLoanInfoContract)(web3, network, block);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(address, marketsAssets_1.compoundV2CollateralAssets.map(a => a.address)).call({}, block);
+    loanInfo.balances.forEach((weiAmount, i) => {
+        const asset = (0, utils_1.wethToEth)(marketsAssets_1.compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? (0, tokens_1.getAssetInfo)(asset, network).address.toLowerCase() : asset]: weiAmount.toString() }),
+        };
+    });
+    loanInfo.borrows.forEach((weiAmount, i) => {
+        const asset = (0, utils_1.wethToEth)(marketsAssets_1.compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset);
+        balances = Object.assign(Object.assign({}, balances), { debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? (0, tokens_1.getAssetInfo)(asset, network).address.toLowerCase() : asset]: weiAmount.toString() }) });
+    });
+    return balances;
+});
+exports.getCompoundV2AccountBalances = getCompoundV2AccountBalances;
+const getCompoundV2AccountData = (web3, network, address, assetsData) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        throw new Error('No address provided');
+    let payload = Object.assign(Object.assign({}, exports.EMPTY_COMPOUND_DATA), { lastUpdated: Date.now() });
+    const loanInfoContract = (0, contracts_1.CompoundLoanInfoContract)(web3, network);
+    const loanInfo = yield loanInfoContract.methods.getTokenBalances(address, marketsAssets_1.compoundV2CollateralAssets.map(a => a.address)).call();
+    const collateralAssetsAddresses = yield (0, exports.getCollateralAssetsAddresses)(web3, network, address);
+    const usedAssets = {};
+    loanInfo.balances.forEach((weiAmount, i) => {
+        const asset = marketsAssets_1.compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset;
+        const amount = (0, tokens_1.assetAmountInEth)(weiAmount.toString(), asset);
+        const collateral = !!collateralAssetsAddresses.find(a => (0, utils_1.compareAddresses)(a, marketsAssets_1.compoundV2CollateralAssets[i].address));
+        if (weiAmount.toString() === '0' && !collateral)
+            return;
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, supplied: amount, suppliedUsd: new decimal_js_1.default(amount).mul(assetsData[(0, utils_1.handleWbtcLegacy)(asset)].price).toString(), isSupplied: +amount > 0, collateral });
+    });
+    loanInfo.borrows.forEach((weiAmount, i) => {
+        if (weiAmount.toString() === '0')
+            return;
+        const asset = marketsAssets_1.compoundV2CollateralAssets[i].symbol === 'cWBTC Legacy'
+            ? `${marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset} Legacy`
+            : marketsAssets_1.compoundV2CollateralAssets[i].underlyingAsset;
+        const amount = (0, tokens_1.assetAmountInEth)(weiAmount.toString(), asset);
+        if (!usedAssets[asset])
+            usedAssets[asset] = {};
+        usedAssets[asset] = Object.assign(Object.assign({}, usedAssets[asset]), { symbol: asset, borrowed: amount, borrowedUsd: new decimal_js_1.default(amount).mul(assetsData[(0, utils_1.handleWbtcLegacy)(asset)].price).toString(), isBorrowed: true, collateral: !!usedAssets[asset].collateral });
+    });
+    payload = Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), (0, compoundHelpers_1.getCompoundV2AggregatedData)({
+        usedAssets, assetsData,
+    }));
+    return payload;
+});
+exports.getCompoundV2AccountData = getCompoundV2AccountData;
+const getCompoundV2FullPositionData = (web3, network, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield (0, exports.getCompoundV2MarketsData)(web3, network);
+    const positionData = yield (0, exports.getCompoundV2AccountData)(web3, network, address, marketData.assetsData);
+    return positionData;
+});
+exports.getCompoundV2FullPositionData = getCompoundV2FullPositionData;

package/cjs/compoundV3/index.d.ts

@@ -0,0 +1,37 @@
+import Web3 from 'web3';
+import { CompoundMarketData, CompoundV3AssetsData, CompoundV3MarketsData, CompoundV3PositionData } from '../types/compound';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+export declare const getCompoundV3MarketsData: (web3: Web3, network: NetworkNumber, selectedMarket: CompoundMarketData, compPrice: string, defaultWeb3: Web3) => Promise<CompoundV3MarketsData>;
+export declare const EMPTY_COMPOUND_V3_DATA: {
+    usedAssets: {};
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    minRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    isSubscribedToAutomation: boolean;
+    automationResubscribeRequired: boolean;
+    isAllowed: boolean;
+    lastUpdated: number;
+};
+export declare const EMPTY_USED_ASSET: {
+    isSupplied: boolean;
+    isBorrowed: boolean;
+    supplied: string;
+    suppliedUsd: string;
+    borrowed: string;
+    borrowedUsd: string;
+    symbol: string;
+    collateral: boolean;
+    debt: string;
+};
+export declare const getCompoundV3AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, marketAddress: EthAddress) => Promise<PositionBalances>;
+export declare const getCompoundV3AccountData: (web3: Web3, network: NetworkNumber, address: string, proxyAddress: string, extractedState: ({
+    selectedMarket: CompoundMarketData;
+    assetsData: CompoundV3AssetsData;
+})) => Promise<CompoundV3PositionData>;
+export declare const getCompoundV3FullPositionData: (web3: Web3, network: NetworkNumber, address: string, proxyAddress: string, selectedMarket: CompoundMarketData, compPrice: string, mainnetWeb3: Web3) => Promise<CompoundV3PositionData>;

package/cjs/compoundV3/index.js

@@ -0,0 +1,208 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompoundV3FullPositionData = exports.getCompoundV3AccountData = exports.getCompoundV3AccountBalances = exports.EMPTY_USED_ASSET = exports.EMPTY_COMPOUND_V3_DATA = exports.getCompoundV3MarketsData = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const tokens_1 = require("@defisaver/tokens");
+const contracts_1 = require("../contracts");
+const multicall_1 = require("../multicall");
+const compound_1 = require("../types/compound");
+const staking_1 = require("../staking");
+const utils_1 = require("../services/utils");
+const constants_1 = require("../constants");
+const moneymarket_1 = require("../moneymarket");
+const compoundHelpers_1 = require("../helpers/compoundHelpers");
+const compound_2 = require("../markets/compound");
+const getCompoundV3MarketsData = (web3, network, selectedMarket, compPrice, defaultWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = (0, contracts_1.CompV3ViewContract)(web3, network);
+    const CompV3ViewAddress = contract.options.address;
+    const calls = [
+        {
+            target: CompV3ViewAddress,
+            abiItem: contract.options.jsonInterface.find((props) => props.name === 'getFullBaseTokenInfo'),
+            params: [selectedMarket.baseMarketAddress],
+        },
+        {
+            target: CompV3ViewAddress,
+            abiItem: contract.options.jsonInterface.find((props) => props.name === 'getFullCollInfos'),
+            params: [selectedMarket.baseMarketAddress],
+        },
+    ];
+    const data = yield (0, multicall_1.multicall)(calls, web3, network);
+    const colls = data[1].colls.map((coll) => (0, compoundHelpers_1.formatMarketData)(coll, network));
+    if (selectedMarket.value === compound_1.CompoundVersions.CompoundV3ETH) {
+        for (const coll of colls) {
+            if (coll.symbol === 'wstETH') {
+                // eslint-disable-next-line no-await-in-loop
+                const [[totalSupplyAlternative, supplyCapAlternative], priceAlternative] = yield Promise.all([
+                    (0, staking_1.getStETHByWstETHMultiple)([
+                        (0, tokens_1.assetAmountInWei)(coll.totalSupply, 'wstETH'),
+                        (0, tokens_1.assetAmountInWei)(coll.supplyCap, 'wstETH'),
+                    ], defaultWeb3),
+                    (0, staking_1.getWstETHByStETH)((0, tokens_1.assetAmountInWei)(1, 'stETH'), defaultWeb3),
+                ]);
+                coll.totalSupplyAlternative = (0, tokens_1.assetAmountInEth)(totalSupplyAlternative, 'stETH');
+                coll.supplyCapAlternative = (0, tokens_1.assetAmountInEth)(supplyCapAlternative, 'stETH');
+                coll.priceAlternative = (0, tokens_1.assetAmountInEth)(priceAlternative, 'wstETH');
+                // const stEthMarket = markets.find(({ symbol }) => symbol === 'stETH');
+                // eslint-disable-next-line no-await-in-loop
+                coll.incentiveSupplyApy = yield (0, staking_1.getStETHApr)(defaultWeb3);
+                coll.incentiveSupplyToken = 'wstETH';
+            }
+            if (coll.symbol === 'cbETH') {
+                // eslint-disable-next-line no-await-in-loop
+                coll.incentiveSupplyApy = yield (0, staking_1.getCbETHApr)(defaultWeb3);
+                coll.incentiveSupplyToken = 'cbETH';
+            }
+        }
+    }
+    const base = (0, compoundHelpers_1.formatBaseData)(data[0].baseToken, network);
+    const payload = {};
+    const baseObj = Object.assign(Object.assign({}, base), (0, compoundHelpers_1.getIncentiveApys)(base, compPrice));
+    const allAssets = [baseObj, ...colls];
+    allAssets
+        .sort((a, b) => {
+        const aMarket = new decimal_js_1.default(a.price).times(a.totalSupply).toString();
+        const bMarket = new decimal_js_1.default(b.price).times(b.totalSupply).toString();
+        return new decimal_js_1.default(bMarket).minus(aMarket).toNumber();
+    })
+        .forEach((market, i) => {
+        payload[market.symbol] = Object.assign(Object.assign({}, market), { sortIndex: i });
+    });
+    return { assetsData: payload };
+});
+exports.getCompoundV3MarketsData = getCompoundV3MarketsData;
+exports.EMPTY_COMPOUND_V3_DATA = {
+    usedAssets: {},
+    suppliedUsd: '0',
+    borrowedUsd: '0',
+    borrowLimitUsd: '0',
+    leftToBorrowUsd: '0',
+    ratio: '0',
+    minRatio: '0',
+    netApy: '0',
+    incentiveUsd: '0',
+    totalInterestUsd: '0',
+    isSubscribedToAutomation: false,
+    automationResubscribeRequired: false,
+    isAllowed: false,
+    lastUpdated: Date.now(),
+};
+exports.EMPTY_USED_ASSET = {
+    isSupplied: false,
+    isBorrowed: false,
+    supplied: '0',
+    suppliedUsd: '0',
+    borrowed: '0',
+    borrowedUsd: '0',
+    symbol: '',
+    collateral: true,
+    debt: '0',
+};
+const getCompoundV3AccountBalances = (web3, network, block, addressMapping, address, marketAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const market = ({
+        [(0, compound_2.COMPOUND_V3_ETH)(network).baseMarketAddress.toLowerCase()]: (0, compound_2.COMPOUND_V3_ETH)(network),
+        [(0, compound_2.COMPOUND_V3_USDC)(network).baseMarketAddress.toLowerCase()]: (0, compound_2.COMPOUND_V3_USDC)(network),
+        [(0, compound_2.COMPOUND_V3_USDBC)(network).baseMarketAddress.toLowerCase()]: (0, compound_2.COMPOUND_V3_USDBC)(network),
+    })[marketAddress];
+    const loanInfoContract = (0, contracts_1.CompV3ViewContract)(web3, network, block);
+    const loanInfo = yield loanInfoContract.methods.getLoanData(market.baseMarketAddress, address).call({}, block);
+    const baseAssetInfo = (0, tokens_1.getAssetInfo)((0, utils_1.wethToEth)(market.baseAsset), network);
+    balances = {
+        collateral: {
+            [addressMapping ? baseAssetInfo.address.toLowerCase() : baseAssetInfo.symbol]: loanInfo.depositAmount,
+        },
+        debt: {
+            [addressMapping ? baseAssetInfo.address.toLowerCase() : baseAssetInfo.symbol]: loanInfo.borrowAmount,
+        },
+    };
+    loanInfo.collAddr.forEach((coll, i) => {
+        const symbol = (0, utils_1.wethToEth)((0, tokens_1.getAssetInfoByAddress)(coll, network).symbol);
+        balances = Object.assign(Object.assign({}, balances), { collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? (0, tokens_1.getAssetInfo)(symbol, network).address.toLowerCase() : symbol]: loanInfo.collAmounts[i].toString() }) });
+    });
+    return balances;
+});
+exports.getCompoundV3AccountBalances = getCompoundV3AccountBalances;
+const getCompoundV3AccountData = (web3, network, address, proxyAddress, extractedState) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        throw new Error('No address provided');
+    const { selectedMarket, assetsData, } = extractedState;
+    let payload = Object.assign(Object.assign({}, exports.EMPTY_COMPOUND_V3_DATA), { lastUpdated: Date.now() });
+    const contract = (0, contracts_1.CompV3ViewContract)(web3, network);
+    const CompV3ViewAddress = contract.options.address;
+    const calls = [
+        {
+            target: CompV3ViewAddress,
+            abiItem: contract.options.jsonInterface.find((props) => props.name === 'getLoanData'),
+            params: [selectedMarket.baseMarketAddress, address],
+        },
+        {
+            target: CompV3ViewAddress,
+            abiItem: contract.options.jsonInterface.find((props) => props.name === 'isAllowed'),
+            params: [selectedMarket.baseMarketAddress, address, proxyAddress || constants_1.ZERO_ADDRESS],
+        },
+    ];
+    const data = yield (0, multicall_1.multicall)(calls, web3, network);
+    const loanData = data[0][0];
+    const usedAssets = {};
+    const baseAssetInfo = (0, tokens_1.getAssetInfo)(selectedMarket.baseAsset);
+    const baseAssetSymbol = (0, utils_1.wethToEth)(selectedMarket.baseAsset);
+    usedAssets[baseAssetSymbol] = Object.assign(Object.assign({}, exports.EMPTY_USED_ASSET), { symbol: baseAssetSymbol, collateral: false });
+    if (loanData.depositAmount.toString() !== '0') {
+        usedAssets[baseAssetSymbol].isSupplied = true;
+        usedAssets[baseAssetSymbol].supplied = (0, tokens_1.assetAmountInEth)(loanData.depositAmount, baseAssetInfo.symbol);
+        usedAssets[baseAssetSymbol].suppliedUsd = (0, tokens_1.assetAmountInEth)(loanData.depositValue, baseAssetInfo.symbol);
+    }
+    if (loanData.borrowAmount.toString() !== '0') {
+        usedAssets[baseAssetSymbol].isBorrowed = true;
+        usedAssets[baseAssetSymbol].borrowed = (0, tokens_1.assetAmountInEth)(loanData.borrowAmount, baseAssetInfo.symbol);
+        usedAssets[baseAssetSymbol].borrowedUsd = (0, tokens_1.assetAmountInEth)(loanData.borrowValue, baseAssetInfo.symbol);
+    }
+    loanData.collAddr.forEach((coll, i) => {
+        const assetInfo = (0, tokens_1.getAssetInfoByAddress)(coll, network);
+        const symbol = (0, utils_1.wethToEth)(assetInfo.symbol);
+        const supplied = (0, tokens_1.assetAmountInEth)(loanData.collAmounts[i].toString(), symbol);
+        const isSupplied = supplied !== '0';
+        const price = assetsData[symbol].price;
+        const suppliedUsd = new decimal_js_1.default(supplied).mul(price).toString();
+        usedAssets[symbol] = Object.assign(Object.assign({}, usedAssets[symbol]), { borrowed: '0', borrowedUsd: '0', isSupplied,
+            supplied,
+            suppliedUsd, isBorrowed: false, symbol, collateral: true });
+    });
+    payload = Object.assign(Object.assign(Object.assign(Object.assign({}, payload), { usedAssets }), (0, compoundHelpers_1.getCompoundV3AggregatedData)({
+        usedAssets, assetsData, network, selectedMarket,
+    })), { isAllowed: data[1][0] });
+    // Calculate borrow limits per asset
+    Object.values(payload.usedAssets).forEach((item) => {
+        if (item.isBorrowed) {
+            // eslint-disable-next-line no-param-reassign
+            item.limit = (0, moneymarket_1.calculateBorrowingAssetLimit)(item.borrowedUsd, payload.borrowLimitUsd);
+        }
+    });
+    return payload;
+});
+exports.getCompoundV3AccountData = getCompoundV3AccountData;
+const getCompoundV3FullPositionData = (web3, network, address, proxyAddress, selectedMarket, compPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield (0, exports.getCompoundV3MarketsData)(web3, network, selectedMarket, compPrice, mainnetWeb3);
+    const positionData = yield (0, exports.getCompoundV3AccountData)(web3, network, address, proxyAddress, { selectedMarket, assetsData: marketData.assetsData });
+    return positionData;
+});
+exports.getCompoundV3FullPositionData = getCompoundV3FullPositionData;