@defisaver/positions-sdk 0.0.1

package/esm/helpers/curveUsdHelpers/index.js

@@ -0,0 +1,35 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import Dec from 'decimal.js';
+import { getAssetsTotal } from '../../moneymarket';
+export const getCrvUsdAggregatedData = (_a) => {
+    var { loanExists, usedAssets, network, selectedMarket } = _a, rest = __rest(_a, ["loanExists", "usedAssets", "network", "selectedMarket"]);
+    const _supplied = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ supplied }) => supplied); // this is wrong if we are in soft-liquidations
+    const _borrowed = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowed }) => borrowed);
+    const _suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    const _borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    const ratio = loanExists
+        ? new Dec(_suppliedUsd)
+            .dividedBy(_borrowedUsd)
+            .times(100)
+            .toString()
+        : '0';
+    // we don't have borrowLimitUsd here
+    return {
+        ratio,
+        supplied: _supplied,
+        suppliedUsd: _suppliedUsd,
+        borrowedUsd: _borrowedUsd,
+        borrowed: _borrowed,
+        safetyRatio: ratio,
+    };
+};

package/esm/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export * as aaveHelpers from './aaveHelpers';
+export * as compoundHelpers from './compoundHelpers';
+export * as sparkHelpers from './sparkHelpers';
+export * as curveUsdHelpers from './curveUsdHelpers';
+export * as makerHelpers from './makerHelpers';

package/esm/helpers/index.js

@@ -0,0 +1,5 @@
+export * as aaveHelpers from './aaveHelpers';
+export * as compoundHelpers from './compoundHelpers';
+export * as sparkHelpers from './sparkHelpers';
+export * as curveUsdHelpers from './curveUsdHelpers';
+export * as makerHelpers from './makerHelpers';

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

@@ -0,0 +1,5 @@
+import Web3 from 'web3';
+import { Blockish, NetworkNumber } from '../../types/common';
+import { IlkInfo } from '../../types';
+export declare const getUnclaimedCollateral: (web3: Web3, network: NetworkNumber, urn: string, ilk: string) => Promise<string>;
+export declare const getCollateralInfo: (ilk: string, web3: Web3, network: NetworkNumber, block?: Blockish) => Promise<IlkInfo>;

package/esm/helpers/makerHelpers/index.js

@@ -0,0 +1,92 @@
+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 { McdDogContract, McdJugContract, McdSpotterContract, McdVatContract, } from '../../contracts';
+import { multicall } from '../../multicall';
+import { SECONDS_PER_YEAR } from '../../constants';
+import { bytesToString } from '../../services/utils';
+export const getUnclaimedCollateral = (web3, network, urn, ilk) => __awaiter(void 0, void 0, void 0, function* () {
+    const vatContract = McdVatContract(web3, network);
+    const coll = yield vatContract.methods.gem(ilk, urn).call();
+    return coll;
+});
+export const getCollateralInfo = (ilk, web3, network, block = 'latest') => __awaiter(void 0, void 0, void 0, function* () {
+    const spotterContract = McdSpotterContract(web3, network);
+    const vatContract = McdVatContract(web3, network);
+    const dogContract = McdDogContract(web3, network);
+    const jugContract = McdJugContract(web3, network);
+    const multicallData = [
+        {
+            target: spotterContract.options.address,
+            abiItem: spotterContract.options.jsonInterface.find(({ name }) => name === 'par'),
+            params: [],
+        },
+        {
+            target: spotterContract.options.address,
+            abiItem: spotterContract.options.jsonInterface.find(({ name }) => name === 'ilks'),
+            params: [ilk],
+        },
+        {
+            target: vatContract.options.address,
+            abiItem: vatContract.options.jsonInterface.find(({ name }) => name === 'ilks'),
+            params: [ilk],
+        },
+        {
+            target: jugContract.options.address,
+            abiItem: jugContract.options.jsonInterface.find(({ name }) => name === 'ilks'),
+            params: [ilk],
+        },
+        {
+            target: jugContract.options.address,
+            abiItem: jugContract.options.jsonInterface.find(({ name }) => name === 'drip'),
+            params: [ilk],
+        },
+        {
+            target: dogContract.options.address,
+            abiItem: dogContract.options.jsonInterface.find(({ name }) => name === 'chop'),
+            params: [ilk],
+        },
+    ];
+    const multiRes = yield multicall(multicallData, web3, network, block);
+    const par = new Dec(multiRes[0][0].toString()).div(1e27).toString();
+    const mat = new Dec(multiRes[1][1].toString()).div(1e27).toString();
+    const art = new Dec(multiRes[2][0].toString()).toString();
+    const rate = new Dec(multiRes[2][1].toString()).toString();
+    const spot = new Dec(multiRes[2][2].toString()).div(1e27).toString();
+    const line = new Dec(multiRes[2][3].toString()).div(1e45).toString();
+    const dust = new Dec(multiRes[2][1].toString()).div(1e45).toString();
+    const duty = new Dec(multiRes[3][0].toString()).toString();
+    const futureRate = new Dec(multiRes[4][0].toString()).toString();
+    const chop = new Dec(multiRes[5][0].toString()).div(1e18).toString();
+    const stabilityFee = new Dec(duty.toString())
+        .div(1e27)
+        .pow(SECONDS_PER_YEAR)
+        .minus(1)
+        .mul(100)
+        .toNumber();
+    const liquidationFee = new Dec(chop).mul(100).sub(100).toString();
+    const globalDebtCurrent = new Dec(art).div(1e18).mul(new Dec(futureRate).div(1e27)).toString();
+    const globalDebtCeiling = line;
+    const creatableDebt = new Dec(globalDebtCeiling).sub(globalDebtCurrent).toString();
+    return {
+        ilkLabel: bytesToString(ilk),
+        currentRate: rate,
+        futureRate,
+        minDebt: dust,
+        globalDebtCurrent,
+        globalDebtCeiling,
+        assetPrice: new Dec(spot).times(par).times(mat).toString(),
+        liqRatio: mat,
+        liqPercent: +mat * 100,
+        stabilityFee,
+        liquidationFee: new Dec(liquidationFee).lt(0) ? '0' : liquidationFee,
+        creatableDebt,
+    };
+});

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

@@ -0,0 +1,21 @@
+import { SparkAggregatedPositionData, SparkAssetsData, SparkHelperCommon, SparkUsedAssets } from '../../types';
+export declare const sparkIsInIsolationMode: ({ usedAssets, assetsData }: {
+    usedAssets: SparkUsedAssets;
+    assetsData: SparkAssetsData;
+}) => boolean;
+export declare const sparkGetCollSuppliedAssets: ({ usedAssets }: {
+    usedAssets: SparkUsedAssets;
+}) => import("../../types").SparkUsedAsset[];
+export declare const sparkGetSuppliableAssets: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: SparkHelperCommon) => {
+    symbol: string;
+    canBeCollateral: boolean;
+}[];
+export declare const sparkGetSuppliableAsCollAssets: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: SparkHelperCommon) => {
+    symbol: string;
+    canBeCollateral: boolean;
+}[];
+export declare const sparkGetEmodeMutableProps: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: SparkHelperCommon, _asset: string) => {
+    liquidationRatio: string;
+    collateralFactor: string;
+};
+export declare const sparkGetAggregatedPositionData: ({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network, ...rest }: SparkHelperCommon) => SparkAggregatedPositionData;

package/esm/helpers/sparkHelpers/index.js

@@ -0,0 +1,84 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import Dec from 'decimal.js';
+import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+import { wethToEth } from '../../services/utils';
+export const sparkIsInIsolationMode = ({ usedAssets, assetsData }) => Object.values(usedAssets).some(({ symbol, collateral }) => collateral && assetsData[symbol].isIsolated);
+export const sparkGetCollSuppliedAssets = ({ usedAssets }) => Object.values(usedAssets).filter(({ isSupplied, collateral }) => isSupplied && collateral);
+export const sparkGetSuppliableAssets = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const collAccountAssets = sparkGetCollSuppliedAssets(data);
+    const marketAssets = Object.values(assetsData);
+    if (sparkIsInIsolationMode(data)) {
+        const collAsset = collAccountAssets[0].symbol;
+        return marketAssets.filter(d => d.canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: symbol === collAsset }));
+    }
+    return marketAssets.filter(d => d.canBeSupplied).map(({ symbol, isIsolated }) => ({ symbol, canBeCollateral: !isIsolated }));
+};
+export const sparkGetSuppliableAsCollAssets = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    return sparkGetSuppliableAssets(Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest)).filter(({ canBeCollateral }) => canBeCollateral);
+};
+export const sparkGetEmodeMutableProps = (_a, _asset) => {
+    var _b;
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const asset = wethToEth(_asset);
+    const canSupplyAsColl = sparkGetSuppliableAsCollAssets(data).some(({ symbol }) => symbol === asset);
+    if (!canSupplyAsColl) {
+        return ({ liquidationRatio: '0', collateralFactor: '0' });
+    }
+    const assetData = assetsData[asset];
+    if (eModeCategory === 0
+        || assetData.eModeCategory !== eModeCategory
+        || new Dec(((_b = assetData === null || assetData === void 0 ? void 0 : assetData.eModeCategoryData) === null || _b === void 0 ? void 0 : _b.collateralFactor) || 0).eq(0)) {
+        const { liquidationRatio, collateralFactor } = assetData;
+        return ({ liquidationRatio, collateralFactor });
+    }
+    const { liquidationRatio, collateralFactor } = assetData.eModeCategoryData;
+    return ({ liquidationRatio, collateralFactor });
+};
+export const sparkGetAggregatedPositionData = (_a) => {
+    var { usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network } = _a, rest = __rest(_a, ["usedAssets", "eModeCategory", "eModeCategories", "assetsData", "selectedMarket", "network"]);
+    const data = Object.assign({ usedAssets, eModeCategory, eModeCategories, assetsData, selectedMarket, network }, rest);
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(sparkGetEmodeMutableProps(data, symbol).collateralFactor));
+    payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => new Dec(suppliedUsd).mul(sparkGetEmodeMutableProps(data, symbol).liquidationRatio));
+    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.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
+    payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        let assetPrice = data.assetsData[leveragedAsset].price; // TODO sparkPrice or 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/index.d.ts

@@ -0,0 +1,19 @@
+import * as aaveV3 from './aaveV3';
+import * as morphoAaveV3 from './morphoAaveV3';
+import * as aaveV2 from './aaveV2';
+import * as morphoAaveV2 from './morphoAaveV2';
+import * as compoundV3 from './compoundV3';
+import * as compoundV2 from './compoundV2';
+import * as spark from './spark';
+import * as curveUsd from './curveUsd';
+import * as liquity from './liquity';
+import * as maker from './maker';
+import * as staking from './staking';
+import * as multicall from './multicall';
+import * as moneymarket from './moneymarket';
+import * as markets from './markets';
+import * as helpers from './helpers';
+import * as chickenBonds from './chickenBonds';
+import * as exchange from './exchange';
+export * from './types';
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, };

package/esm/index.js

@@ -0,0 +1,19 @@
+import * as aaveV3 from './aaveV3';
+import * as morphoAaveV3 from './morphoAaveV3';
+import * as aaveV2 from './aaveV2';
+import * as morphoAaveV2 from './morphoAaveV2';
+import * as compoundV3 from './compoundV3';
+import * as compoundV2 from './compoundV2';
+import * as spark from './spark';
+import * as curveUsd from './curveUsd';
+import * as liquity from './liquity';
+import * as maker from './maker';
+import * as staking from './staking';
+import * as multicall from './multicall';
+import * as moneymarket from './moneymarket';
+import * as markets from './markets';
+import * as helpers from './helpers';
+import * as chickenBonds from './chickenBonds';
+import * as exchange from './exchange';
+export * from './types';
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, };

package/esm/liquity/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { LiquityTroveInfo } from '../types';
+export declare const LIQUITY_NORMAL_MODE_RATIO = 110;
+export declare const LIQUITY_RECOVERY_MODE_RATIO = 150;
+export declare const getLiquityAccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getLiquityTroveInfo: (web3: Web3, network: NetworkNumber, address: string) => Promise<LiquityTroveInfo>;

package/esm/liquity/index.js

@@ -0,0 +1,95 @@
+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 { LiquityActivePoolContract, LiquityCollSurplusPoolContract, LiquityPriceFeedContract, LiquityTroveManagerContract, LiquityViewContract, } from '../contracts';
+import { multicall } from '../multicall';
+import { LIQUITY_TROVE_STATUS_ENUM } from '../types';
+export const LIQUITY_NORMAL_MODE_RATIO = 110; // MCR
+export const LIQUITY_RECOVERY_MODE_RATIO = 150; // CCR
+export const getLiquityAccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const viewContract = LiquityViewContract(web3, network, block);
+    const troveInfo = yield viewContract.methods.getTroveInfo(address).call({}, block);
+    balances = {
+        collateral: {
+            [addressMapping ? getAssetInfo('ETH', network).address.toLowerCase() : 'ETH']: troveInfo[1],
+        },
+        debt: {
+            [addressMapping ? getAssetInfo('LUSD', network).address.toLowerCase() : 'LUSD']: troveInfo[2],
+        },
+    };
+    return balances;
+});
+export const getLiquityTroveInfo = (web3, network, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityViewContract(web3, network);
+    const collSurplusPoolContract = LiquityCollSurplusPoolContract(web3, network);
+    const troveManagerContract = LiquityTroveManagerContract(web3, network);
+    const priceFeedContract = LiquityPriceFeedContract(web3, network);
+    const activePoolContract = LiquityActivePoolContract(web3, network);
+    const multicallData = [
+        {
+            target: viewContract.options.address,
+            abiItem: viewContract.options.jsonInterface.find(({ name }) => name === 'getTroveInfo'),
+            params: [address],
+        },
+        {
+            target: collSurplusPoolContract.options.address,
+            abiItem: collSurplusPoolContract.options.jsonInterface.find(({ name }) => name === 'getCollateral'),
+            params: [address],
+        },
+        {
+            target: troveManagerContract.options.address,
+            abiItem: troveManagerContract.options.jsonInterface.find(({ name }) => name === 'getBorrowingRateWithDecay'),
+            params: [],
+        },
+        {
+            target: priceFeedContract.options.address,
+            abiItem: priceFeedContract.options.jsonInterface.find(({ name }) => name === 'fetchPrice'),
+            params: [],
+        },
+        {
+            target: activePoolContract.options.address,
+            abiItem: activePoolContract.options.jsonInterface.find(({ name }) => name === 'getETH'),
+            params: [],
+        },
+        {
+            target: activePoolContract.options.address,
+            abiItem: activePoolContract.options.jsonInterface.find(({ name }) => name === 'getLUSDDebt'),
+            params: [],
+        },
+    ];
+    const multiRes = yield multicall(multicallData, web3, network);
+    const recoveryMode = multiRes[0][6];
+    const totalETH = multiRes[4][0];
+    const totalLUSD = multiRes[5][0];
+    const payload = {
+        troveStatus: LIQUITY_TROVE_STATUS_ENUM[+multiRes[0][0].toString()],
+        collateral: assetAmountInEth(multiRes[0][1]),
+        debtInAsset: assetAmountInEth(multiRes[0][2]),
+        TCRatio: assetAmountInEth(multiRes[0][4]),
+        recoveryMode,
+        claimableCollateral: assetAmountInEth(multiRes[1][0]),
+        borrowingRateWithDecay: assetAmountInEth(multiRes[2][0]),
+        assetPrice: assetAmountInEth(multiRes[3][0]),
+        totalETH,
+        totalLUSD,
+        minCollateralRatio: recoveryMode ? LIQUITY_RECOVERY_MODE_RATIO : LIQUITY_NORMAL_MODE_RATIO,
+        priceForRecovery: new Dec(recoveryMode ? LIQUITY_RECOVERY_MODE_RATIO : LIQUITY_NORMAL_MODE_RATIO).mul(totalLUSD).div(totalETH).div(100)
+            .toString(),
+    };
+    return payload;
+});

package/esm/maker/index.d.ts

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

package/esm/maker/index.js

@@ -0,0 +1,95 @@
+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, ilkToAsset } from '@defisaver/tokens';
+import { McdViewContract } from '../contracts';
+import { makerHelpers } from '../helpers';
+import { wethToEth } from '../services/utils';
+export const getMakerAccountBalances = (web3, network, block, addressMapping, cdpId) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!cdpId) {
+        return balances;
+    }
+    const viewContract = McdViewContract(web3, network, block);
+    // @ts-ignore
+    const cdpInfo = yield viewContract.methods.getCdpInfo(cdpId).call({}, block);
+    const ilkInfo = yield makerHelpers.getCollateralInfo(cdpInfo.ilk, web3, network, block);
+    const asset = wethToEth(ilkToAsset(cdpInfo.ilk));
+    balances = {
+        collateral: {
+            [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: asset === 'WBTC' ? new Dec(cdpInfo.collateral).div(1e10).floor().toString() : cdpInfo.collateral,
+        },
+        debt: {
+            [addressMapping ? getAssetInfo('DAI', network).address.toLowerCase() : 'DAI']: new Dec(cdpInfo.debt).times(ilkInfo.currentRate).div(1e27).floor()
+                .toString(),
+        },
+    };
+    return balances;
+});
+export const getMakerCdpData = (web3, network, cdpId) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = McdViewContract(web3, network);
+    // @ts-ignore
+    const cdpInfo = yield viewContract.methods.getCdpInfo(cdpId).call();
+    const [ilkInfo, coll] = yield Promise.all([
+        makerHelpers.getCollateralInfo(cdpInfo.ilk, web3, network),
+        makerHelpers.getUnclaimedCollateral(web3, network, cdpInfo.urn, cdpInfo.ilk),
+    ]);
+    const asset = ilkToAsset(cdpInfo.ilk);
+    const collateralUsd = new Dec(cdpInfo.collateral).mul(ilkInfo.assetPrice).floor().toString();
+    const debt = new Dec(cdpInfo.debt).times(ilkInfo.currentRate).div(1e27).floor()
+        .toString();
+    const futureDebt = new Dec(cdpInfo.debt).times(ilkInfo.futureRate).div(1e27).floor()
+        .toString(); // after drip
+    const debtDripDelta = assetAmountInEth(new Dec(futureDebt).sub(debt).toString(), 'DAI');
+    const liquidationPrice = new Dec(debt).times(ilkInfo.liqRatio).div(cdpInfo.collateral).toString();
+    let ratio = new Dec(cdpInfo.collateral).times(ilkInfo.assetPrice).div(debt).times(100)
+        .toString();
+    if (new Dec(debt).eq(0))
+        ratio = '0';
+    const debtTooLow = new Dec(debt).gt(0) && new Dec(assetAmountInEth(debt, 'DAI')).lt(ilkInfo.minDebt);
+    const par = '1';
+    return {
+        owner: cdpInfo.owner,
+        userAddress: cdpInfo.userAddr,
+        id: cdpId,
+        urn: cdpInfo.urn,
+        type: 'mcd',
+        ilk: cdpInfo.ilk,
+        ilkLabel: ilkInfo.ilkLabel,
+        asset,
+        collateral: assetAmountInEth(cdpInfo.collateral, `MCD-${asset}`),
+        collateralUsd: assetAmountInEth(collateralUsd, `MCD-${asset}`),
+        futureDebt: assetAmountInEth(futureDebt, 'DAI'),
+        debtDai: assetAmountInEth(debt, 'DAI'),
+        debtUsd: assetAmountInEth(debt, 'DAI'),
+        debtInAsset: assetAmountInEth(debt, 'DAI'),
+        debtAssetPrice: par,
+        debtAssetMarketPrice: par,
+        liquidationPrice,
+        ratio,
+        liqRatio: ilkInfo.liqRatio.toString(),
+        liqPercent: parseFloat(ilkInfo.liqPercent.toString()),
+        assetPrice: ilkInfo.assetPrice,
+        daiLabel: 'DAI',
+        debtAsset: 'DAI',
+        unclaimedCollateral: assetAmountInEth(coll, asset),
+        debtTooLow,
+        minDebt: ilkInfo.minDebt,
+        stabilityFee: ilkInfo.stabilityFee,
+        creatableDebt: ilkInfo.creatableDebt,
+        globalDebtCeiling: ilkInfo.globalDebtCeiling,
+        globalDebtCurrent: ilkInfo.globalDebtCurrent,
+        liquidationFee: ilkInfo.liquidationFee,
+        lastUpdated: Date.now(),
+    };
+});

package/esm/markets/aave/index.d.ts

@@ -0,0 +1,12 @@
+import { AaveMarketInfo, MorphoAaveV2MarketInfo, MorphoAaveV3MarketInfo } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const AAVE_V2: AaveMarketInfo;
+export declare const AAVE_V3: (networkId: NetworkNumber) => AaveMarketInfo;
+export declare const MORPHO_AAVE_V2: MorphoAaveV2MarketInfo;
+export declare const MORPHO_AAVE_V3_ETH: (networkId?: NetworkNumber) => MorphoAaveV3MarketInfo;
+export declare const AaveMarkets: (networkId: NetworkNumber) => {
+    readonly v2default: AaveMarketInfo;
+    readonly v3default: AaveMarketInfo;
+    readonly morphoAaveV3Eth: MorphoAaveV3MarketInfo;
+    readonly morphoAaveV2: MorphoAaveV2MarketInfo;
+};

package/esm/markets/aave/index.js

@@ -0,0 +1,70 @@
+import { getConfigContractAddress } from '../../contracts';
+import { AaveVersions, } from '../../types';
+import { NetworkNumber } from '../../types/common';
+import { aaveV2AssetsDefaultMarket, aaveV3AssetsDefaultMarket, morphoAaveV2AssetDefaultMarket, morphoAaveV3AssetEthMarket, } from './marketAssets';
+export const AAVE_V2 = {
+    chainIds: [1],
+    label: 'Aave v2',
+    shortLabel: 'v2',
+    value: AaveVersions.AaveV2,
+    url: 'default',
+    assets: aaveV2AssetsDefaultMarket,
+    provider: 'LendingPoolAddressesProvider',
+    providerAddress: getConfigContractAddress('LendingPoolAddressesProvider', 1),
+    lendingPool: 'AaveLendingPoolV2',
+    lendingPoolAddress: getConfigContractAddress('AaveLendingPoolV2', 1),
+    protocolData: 'AaveProtocolDataProvider',
+    protocolDataAddress: getConfigContractAddress('AaveProtocolDataProvider', 1),
+    // icon: SvgAdapter(protocolIcons.aave),
+    protocolName: 'aave',
+};
+export const AAVE_V3 = (networkId) => ({
+    chainIds: [NetworkNumber.Eth, NetworkNumber.Opt, NetworkNumber.Arb, NetworkNumber.Base],
+    label: 'Aave v3',
+    shortLabel: 'v3',
+    value: AaveVersions.AaveV3,
+    url: 'default',
+    assets: networkId ? aaveV3AssetsDefaultMarket[networkId] : [],
+    provider: 'AaveV3PoolAddressesProvider',
+    providerAddress: getConfigContractAddress('AaveV3PoolAddressesProvider', networkId),
+    lendingPool: 'AaveV3LendingPool',
+    lendingPoolAddress: getConfigContractAddress('AaveV3LendingPool', networkId),
+    protocolData: 'AaveV3ProtocolDataProvider',
+    protocolDataAddress: getConfigContractAddress('AaveV3ProtocolDataProvider', networkId),
+    // icon: SvgAdapter(protocolIcons.aave),
+    protocolName: 'aave',
+});
+export const MORPHO_AAVE_V2 = {
+    chainIds: [1],
+    label: 'Morpho-Aave V2',
+    shortLabel: 'morpho-aave-v2',
+    value: AaveVersions.MorphoAaveV2,
+    url: '',
+    assets: morphoAaveV2AssetDefaultMarket,
+    providerAddress: getConfigContractAddress('LendingPoolAddressesProvider', 1),
+    lendingPoolAddress: getConfigContractAddress('MorphoAaveV2Proxy', 1),
+    // icon: SvgAdapter(protocolIcons.morpho),
+    protocolName: 'morpho',
+};
+export const MORPHO_AAVE_V3_ETH = (networkId = NetworkNumber.Eth) => ({
+    chainIds: [1],
+    label: 'Morpho-Aave V3',
+    shortLabel: 'morpho-aave-v3',
+    subVersionLabel: 'ETH Optimizer',
+    value: AaveVersions.MorphoAaveV3Eth,
+    url: 'eth-optimizer',
+    assets: morphoAaveV3AssetEthMarket,
+    providerAddress: getConfigContractAddress('AaveV3PoolAddressesProvider', networkId),
+    protocolData: 'AaveV3ProtocolDataProvider',
+    protocolDataAddress: getConfigContractAddress('AaveV3ProtocolDataProvider', networkId),
+    lendingPool: 'MorphoAaveV3ProxyEthMarket',
+    lendingPoolAddress: getConfigContractAddress('MorphoAaveV3ProxyEthMarket', 1),
+    // icon: SvgAdapter(protocolIcons.morpho),
+    protocolName: 'morpho',
+});
+export const AaveMarkets = (networkId) => ({
+    [AaveVersions.AaveV2]: AAVE_V2,
+    [AaveVersions.AaveV3]: AAVE_V3(networkId),
+    [AaveVersions.MorphoAaveV3Eth]: MORPHO_AAVE_V3_ETH(networkId),
+    [AaveVersions.MorphoAaveV2]: MORPHO_AAVE_V2,
+});

package/esm/markets/aave/marketAssets.d.ts

@@ -0,0 +1,9 @@
+export declare const aaveV2AssetsDefaultMarket: readonly ["AAVE", "BAL", "BAT", "BUSD", "CRV", "DAI", "ENJ", "ETH", "GUSD", "LINK", "MANA", "MKR", "REN", "SNX", "SUSD", "TUSD", "UNI", "USDC", "USDT", "WBTC", "YFI", "xSUSHI", "ZRX", "RAI", "AMPL", "DPI", "USDP", "RENFIL", "FRAX", "FEI", "stETH", "ENS", "UST", "CVX", "1INCH", "LUSD"];
+export declare const morphoAaveV2AssetDefaultMarket: string[];
+export declare const morphoAaveV3AssetEthMarket: string[];
+export declare const aaveV3AssetsDefaultMarket: {
+    readonly 1: readonly ["WBTC", "ETH", "wstETH", "USDC", "DAI", "LINK", "AAVE", "cbETH", "USDT", "rETH", "LUSD", "UNI", "MKR", "SNX", "BAL", "LDO", "CRV", "ENS", "1INCH", "GHO", "FRAX", "RPL", "sDAI"];
+    readonly 10: readonly ["DAI", "USDC.e", "USDT", "SUSD", "AAVE", "LINK", "WBTC", "ETH", "OP", "wstETH", "LUSD", "MAI", "rETH"];
+    readonly 42161: readonly ["ETH", "DAI", "EURS", "USDC", "USDT", "AAVE", "LINK", "WBTC", "wstETH", "MAI", "rETH", "LUSD", "USDC.e", "FRAX", "ARB"];
+    readonly 8453: readonly ["ETH", "USDbC", "cbETH"];
+};

package/esm/markets/aave/marketAssets.js

@@ -0,0 +1,28 @@
+// TODO generate this file automatically
+import { NetworkNumber } from '../../types/common';
+export const aaveV2AssetsDefaultMarket = [
+    'AAVE', 'BAL', 'BAT', 'BUSD', 'CRV', 'DAI', 'ENJ', 'ETH', 'GUSD', 'LINK', 'MANA', 'MKR',
+    'REN', 'SNX', 'SUSD', 'TUSD', 'UNI', 'USDC', 'USDT', 'WBTC', 'YFI', 'xSUSHI', 'ZRX', 'RAI',
+    'AMPL', 'DPI', 'USDP', 'RENFIL', 'FRAX', 'FEI', 'stETH', 'ENS', 'UST', 'CVX', '1INCH', 'LUSD',
+];
+export const morphoAaveV2AssetDefaultMarket = [
+    'ETH', 'stETH', 'USDC', 'WBTC', 'USDT', 'DAI', 'CRV',
+];
+export const morphoAaveV3AssetEthMarket = [
+    'ETH', 'wstETH', 'DAI', 'USDC', 'WBTC', 'rETH', 'cbETH',
+];
+export const aaveV3AssetsDefaultMarket = {
+    [NetworkNumber.Eth]: [
+        'WBTC', 'ETH', 'wstETH', 'USDC', 'DAI', 'LINK', 'AAVE', 'cbETH', 'USDT', 'rETH', 'LUSD', 'UNI', 'MKR', 'SNX', 'BAL',
+        'LDO', 'CRV', 'ENS', '1INCH', 'GHO', 'FRAX', 'RPL', 'sDAI',
+    ],
+    [NetworkNumber.Opt]: [
+        'DAI', 'USDC.e', 'USDT', 'SUSD', 'AAVE', 'LINK', 'WBTC', 'ETH', 'OP', 'wstETH', 'LUSD', 'MAI', 'rETH',
+    ],
+    [NetworkNumber.Arb]: [
+        'ETH', 'DAI', 'EURS', 'USDC', 'USDT', 'AAVE', 'LINK', 'WBTC', 'wstETH', 'MAI', 'rETH', 'LUSD', 'USDC.e', 'FRAX', 'ARB',
+    ],
+    [NetworkNumber.Base]: [
+        'ETH', 'USDbC', 'cbETH',
+    ],
+};

package/esm/markets/compound/index.d.ts

@@ -0,0 +1,12 @@
+import { CompoundMarketData } from '../../types';
+import { NetworkNumber } from '../../types/common';
+export declare const COMPOUND_V2: CompoundMarketData;
+export declare const COMPOUND_V3_USDC: (networkId: NetworkNumber) => CompoundMarketData;
+export declare const COMPOUND_V3_ETH: (networkId: NetworkNumber) => CompoundMarketData;
+export declare const COMPOUND_V3_USDBC: (networkId: NetworkNumber) => CompoundMarketData;
+export declare const CompoundMarkets: (networkId: NetworkNumber) => {
+    readonly v2: CompoundMarketData;
+    readonly "v3-ETH": CompoundMarketData;
+    readonly "v3-USDC": CompoundMarketData;
+    readonly "v3-USDbC": CompoundMarketData;
+};