@defisaver/positions-sdk 0.0.1

package/cjs/moneymarket/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./moneymarketCommonService"), exports);

package/cjs/moneymarket/moneymarketCommonService.d.ts

@@ -0,0 +1,12 @@
+import { MMUsedAssets } from '../types/common';
+export declare const getAssetsTotal: (assets: object, filter: any, transform: any) => any;
+export declare const calcLongLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calcShortLiqPrice: (assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calcLeverageLiqPrice: (leverageType: string, assetPrice: string, borrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const calculateBorrowingAssetLimit: (assetBorrowedUsd: string, borrowLimitUsd: string) => string;
+export declare const STABLE_ASSETS: string[];
+export declare const isLeveragedPos: (usedAssets: MMUsedAssets, dustLimit?: number) => {
+    leveragedType: string;
+    leveragedAsset: string;
+};
+export declare const aprToApy: (interest: string | number, frequency?: number) => number;

package/cjs/moneymarket/moneymarketCommonService.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aprToApy = exports.isLeveragedPos = exports.STABLE_ASSETS = exports.calculateBorrowingAssetLimit = exports.calcLeverageLiqPrice = exports.calcShortLiqPrice = exports.calcLongLiqPrice = exports.getAssetsTotal = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const constants_1 = require("../constants");
+const getAssetsTotal = (assets, filter, transform) => Object.values(assets)
+    .filter(filter)
+    .map(transform)
+    .reduce((acc, data) => new decimal_js_1.default(acc).add(data), '0')
+    .toString();
+exports.getAssetsTotal = getAssetsTotal;
+const calcLongLiqPrice = (assetPrice, borrowedUsd, borrowLimitUsd) => new decimal_js_1.default(assetPrice).mul(borrowedUsd).div(borrowLimitUsd).toString();
+exports.calcLongLiqPrice = calcLongLiqPrice;
+const calcShortLiqPrice = (assetPrice, borrowedUsd, borrowLimitUsd) => new decimal_js_1.default(assetPrice).div(borrowedUsd).mul(borrowLimitUsd).toString();
+exports.calcShortLiqPrice = calcShortLiqPrice;
+const calcLeverageLiqPrice = (leverageType, assetPrice, borrowedUsd, borrowLimitUsd) => {
+    if (leverageType === 'short')
+        return (0, exports.calcShortLiqPrice)(assetPrice, borrowedUsd, borrowLimitUsd);
+    if (leverageType === 'long' || leverageType === 'lsd-leverage')
+        return (0, exports.calcLongLiqPrice)(assetPrice, borrowedUsd, borrowLimitUsd);
+    console.error('invalid leverageType', leverageType);
+    return '0';
+};
+exports.calcLeverageLiqPrice = calcLeverageLiqPrice;
+const calculateBorrowingAssetLimit = (assetBorrowedUsd, borrowLimitUsd) => new decimal_js_1.default(assetBorrowedUsd).div(borrowLimitUsd).times(100).toString();
+exports.calculateBorrowingAssetLimit = calculateBorrowingAssetLimit;
+exports.STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI'];
+const isLeveragedPos = (usedAssets, dustLimit = 5) => {
+    let borrowUnstable = 0;
+    let supplyStable = 0;
+    let borrowStable = 0;
+    let supplyUnstable = 0;
+    let longAsset = '';
+    let shortAsset = '';
+    Object.values(usedAssets).forEach(({ symbol, suppliedUsd, borrowedUsd, collateral, }) => {
+        const isSupplied = (+suppliedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        const isBorrowed = (+borrowedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        if (isSupplied && exports.STABLE_ASSETS.includes(symbol) && collateral)
+            supplyStable += 1;
+        if (isBorrowed && exports.STABLE_ASSETS.includes(symbol))
+            borrowStable += 1;
+        if (isBorrowed && !exports.STABLE_ASSETS.includes(symbol)) {
+            borrowUnstable += 1;
+            shortAsset = symbol;
+        }
+        if (isSupplied && !exports.STABLE_ASSETS.includes(symbol) && collateral) {
+            supplyUnstable += 1;
+            longAsset = symbol;
+        }
+    });
+    const isLong = borrowStable > 0 && borrowUnstable === 0 && supplyUnstable === 1 && supplyStable === 0;
+    const isShort = supplyStable > 0 && supplyUnstable === 0 && borrowUnstable === 1 && borrowStable === 0;
+    // lsd -> liquid staking derivative
+    const isLsdLeveraged = supplyUnstable === 1 && borrowUnstable === 1 && shortAsset === 'ETH' && ['stETH', 'wstETH', 'cbETH', 'rETH'].includes(longAsset);
+    if (isLong) {
+        return {
+            leveragedType: 'long',
+            leveragedAsset: longAsset,
+        };
+    }
+    if (isShort) {
+        return {
+            leveragedType: 'short',
+            leveragedAsset: shortAsset,
+        };
+    }
+    if (isLsdLeveraged) {
+        return {
+            leveragedType: 'lsd-leverage',
+            leveragedAsset: longAsset,
+        };
+    }
+    return {
+        leveragedType: '',
+        leveragedAsset: '',
+    };
+};
+exports.isLeveragedPos = isLeveragedPos;
+const aprToApy = (interest, frequency = constants_1.BLOCKS_IN_A_YEAR) => (Math.pow((1 + (+interest / 100) / frequency), frequency) - 1) * 100; // eslint-disable-line
+exports.aprToApy = aprToApy;

package/cjs/morphoAaveV2/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { MorphoAaveV2AssetsData, MorphoAaveV2MarketData, MorphoAaveV2PositionData } from '../types';
+export declare const getMorphoAaveV2MarketsData: (web3: Web3, network: NetworkNumber, ethPrice: string, mainnetWeb3: Web3) => Promise<MorphoAaveV2MarketData>;
+export declare const getMorphoAaveV2AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getMorphoAaveV2AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: MorphoAaveV2AssetsData) => Promise<MorphoAaveV2PositionData>;
+export declare const getMorphoAaveV2FullPositionData: (web3: Web3, network: NetworkNumber, address: string, ethPrice: string, mainnetWeb3: Web3) => Promise<MorphoAaveV2PositionData>;

package/cjs/morphoAaveV2/index.js

@@ -0,0 +1,209 @@
+"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.getMorphoAaveV2FullPositionData = exports.getMorphoAaveV2AccountData = exports.getMorphoAaveV2AccountBalances = exports.getMorphoAaveV2MarketsData = void 0;
+const tokens_1 = require("@defisaver/tokens");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const utils_1 = require("../services/utils");
+const staking_1 = require("../staking");
+const contracts_1 = require("../contracts");
+const types_1 = require("../types");
+const moneymarket_1 = require("../moneymarket");
+const aaveV3_1 = require("../aaveV3");
+const aaveHelpers_1 = require("../helpers/aaveHelpers");
+const getMorphoAaveV2MarketsData = (web3, network, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const morphoAaveV2ViewContract = (0, contracts_1.MorphoAaveV2ViewContract)(web3, network);
+    const [contractData, morphoRewardsRes] = yield Promise.allSettled([
+        morphoAaveV2ViewContract.methods.getAllMarketsInfo().call(),
+        fetch('https://api.morpho.xyz/rewards/distribution'),
+    ]);
+    if (contractData.status !== 'fulfilled') {
+        throw new Error('Failed to fetch market data.');
+    }
+    const { marketInfo, aaveTokenInfo } = contractData.value;
+    const morphoRewardsData = morphoRewardsRes.status === 'fulfilled' ? yield morphoRewardsRes.value.json() : null;
+    const assetsData = marketInfo.map((market, index) => {
+        var _a;
+        const aaveInfo = aaveTokenInfo[index];
+        const { symbol, address } = (0, tokens_1.getAssetInfoByAddress)((0, utils_1.wethToEthByAddress)(aaveInfo.underlyingTokenAddress));
+        const morphoReward = (_a = morphoRewardsData === null || morphoRewardsData === void 0 ? void 0 : morphoRewardsData.markets) === null || _a === void 0 ? void 0 : _a[aaveInfo.aTokenAddress.toLowerCase()];
+        const supplyRateP2P = new decimal_js_1.default(market.p2pSupplyRate).div(1e25).toString();
+        const borrowRateP2P = new decimal_js_1.default(market.p2pBorrowRate).div(1e25).toString();
+        const hasDelta = new decimal_js_1.default(borrowRateP2P).minus(supplyRateP2P).gte(0.3);
+        return {
+            symbol,
+            hasDelta,
+            aTokenAddress: aaveInfo.aTokenAddress,
+            underlyingTokenAddress: address,
+            priceInEth: new decimal_js_1.default(aaveInfo.price).div(1e18).toString(),
+            price: new decimal_js_1.default(aaveInfo.price).div(1e18).times(ethPrice).toString(),
+            supplyRate: new decimal_js_1.default(market.poolSupplyRate).div(1e25).toString(),
+            supplyRateP2P,
+            borrowRate: new decimal_js_1.default(market.poolBorrowRate).div(1e25).toString(),
+            borrowRateP2P,
+            totalSupply: (0, tokens_1.assetAmountInEth)(aaveInfo.totalSupply, symbol),
+            totalBorrow: (0, tokens_1.assetAmountInEth)(aaveInfo.totalBorrow, symbol),
+            totalSupplyP2P: (0, tokens_1.assetAmountInEth)(market.p2pSupplyAmount, symbol),
+            totalSupplyPool: (0, tokens_1.assetAmountInEth)(market.poolSupplyAmount, symbol),
+            totalBorrowP2P: (0, tokens_1.assetAmountInEth)(market.p2pBorrowAmount, symbol),
+            totalBorrowPool: (0, tokens_1.assetAmountInEth)(market.poolBorrowAmount, symbol),
+            collateralFactor: new decimal_js_1.default(aaveInfo.collateralFactor).div(10000).toString(),
+            liquidationRatio: new decimal_js_1.default(aaveInfo.liquidationRatio).div(10000).toString(),
+            isInactive: !aaveInfo.isActive,
+            isFrozen: aaveInfo.isFrozen,
+            canBeBorrowed: aaveInfo.borrowingEnabled
+                && !aaveInfo.isFrozen
+                && !(market.pauseStatus.isBorrowPaused || market.pauseStatus.isDeprecated),
+            canBeWithdrawn: !market.pauseStatus.isWithdrawPaused,
+            canBePayBacked: !market.pauseStatus.isRepayPaused,
+            canBeSupplied: !aaveInfo.isFrozen && !(market.pauseStatus.isSupplyPaused || market.pauseStatus.isDeprecated),
+            reserveFactor: market.reserveFactor,
+            pauseStatus: market.pauseStatus,
+            incentiveSupplyToken: 'MORPHO',
+            incentiveBorrowToken: 'MORPHO',
+            incentiveSupplyApy: new decimal_js_1.default((morphoReward === null || morphoReward === void 0 ? void 0 : morphoReward.supplyRate) || 0).div(1e18).toString(),
+            incentiveBorrowApy: new decimal_js_1.default((morphoReward === null || morphoReward === void 0 ? void 0 : morphoReward.borrowRate) || 0).div(1e18).toString(),
+            marketLiquidity: (0, tokens_1.assetAmountInEth)(new decimal_js_1.default(aaveInfo.totalSupply.toString())
+                .sub(aaveInfo.totalBorrow.toString())
+                .toString(), symbol),
+            utilization: new decimal_js_1.default(aaveInfo.totalBorrow.toString())
+                .div(new decimal_js_1.default(aaveInfo.totalSupply.toString()))
+                .times(100)
+                .toString(),
+            totalBorrowVar: '0',
+            usageAsCollateralEnabled: false,
+            disabledStableBorrowing: false,
+            borrowRateStable: '0',
+            supplyCap: '0',
+            borrowCap: '0',
+        };
+    });
+    const stEthMarket = assetsData.find(({ symbol }) => symbol === 'stETH');
+    if (stEthMarket) {
+        stEthMarket.incentiveSupplyApy = yield (0, staking_1.getStETHApr)(mainnetWeb3);
+        stEthMarket.incentiveSupplyToken = 'stETH';
+    }
+    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((assetData, i) => {
+        payload[assetData.symbol] = Object.assign(Object.assign({}, assetData), { sortIndex: i });
+    });
+    return { assetsData: payload };
+});
+exports.getMorphoAaveV2MarketsData = getMorphoAaveV2MarketsData;
+const getMorphoAaveV2AccountBalances = (web3, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+    let balances = {
+        collateral: {},
+        debt: {},
+    };
+    if (!address) {
+        return balances;
+    }
+    const morphoAaveV2ViewContract = (0, contracts_1.MorphoAaveV2ViewContract)(web3, network, block);
+    const { userBalances } = yield morphoAaveV2ViewContract.methods.getUserInfo(address).call({}, block);
+    if (userBalances.length === 0) {
+        return balances;
+    }
+    userBalances.forEach((balance) => {
+        const { symbol, address: assetAddr } = (0, tokens_1.getAssetInfoByAddress)((0, utils_1.wethToEthByAddress)(balance.underlying, network), network);
+        balances = {
+            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? assetAddr.toLowerCase() : symbol]: new decimal_js_1.default(balance.supplyBalanceInP2P).add(balance.supplyBalanceOnPool).toString() }),
+            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? assetAddr.toLowerCase() : symbol]: new decimal_js_1.default(balance.borrowBalanceInP2P).add(balance.borrowBalanceOnPool).toString() }),
+        };
+    });
+    return balances;
+});
+exports.getMorphoAaveV2AccountBalances = getMorphoAaveV2AccountBalances;
+const getMorphoAaveV2AccountData = (web3, network, address, assetsData) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address) {
+        throw new Error('Address is required.');
+    }
+    let payload = Object.assign(Object.assign({}, aaveV3_1.EMPTY_AAVE_DATA), { usedAssets: {}, minRatio: '100', lastUpdated: Date.now() });
+    const morphoAaveV2ViewContract = (0, contracts_1.MorphoAaveV2ViewContract)(web3, network);
+    const { userBalances } = yield morphoAaveV2ViewContract.methods.getUserInfo(address).call();
+    if (userBalances.length === 0) {
+        return payload;
+    }
+    userBalances.forEach((market) => {
+        const { symbol } = (0, tokens_1.getAssetInfoByAddress)((0, utils_1.wethToEthByAddress)(market.underlying));
+        const suppliedP2P = (0, tokens_1.assetAmountInEth)(market.supplyBalanceInP2P, symbol);
+        const suppliedPool = (0, tokens_1.assetAmountInEth)(market.supplyBalanceOnPool, symbol);
+        const supplied = new decimal_js_1.default(suppliedP2P).add(suppliedPool).toString();
+        const suppliedMatched = new decimal_js_1.default(suppliedP2P).div(supplied).mul(100).toDP(2)
+            .toString();
+        const assetAavePrice = assetsData[symbol].price;
+        const borrowedP2P = (0, tokens_1.assetAmountInEth)(market.borrowBalanceInP2P, symbol);
+        const borrowedPool = (0, tokens_1.assetAmountInEth)(market.borrowBalanceOnPool, symbol);
+        const borrowed = new decimal_js_1.default(borrowedP2P).add(borrowedPool).toString();
+        const borrowedMatched = new decimal_js_1.default(borrowedP2P).div(borrowed).mul(100).toDP(2)
+            .toString();
+        const borrowedUsd = new decimal_js_1.default(borrowed).mul(assetAavePrice).toString();
+        payload.usedAssets[symbol] = {
+            symbol,
+            supplied,
+            suppliedP2P,
+            suppliedPool,
+            suppliedMatched,
+            borrowed,
+            borrowedP2P,
+            borrowedPool,
+            borrowedMatched,
+            suppliedUsd: new decimal_js_1.default(supplied).mul(assetAavePrice).toString(),
+            suppliedP2PUsd: new decimal_js_1.default(suppliedP2P).mul(assetAavePrice).toString(),
+            suppliedPoolUsd: new decimal_js_1.default(suppliedPool).mul(assetAavePrice).toString(),
+            borrowedUsd,
+            borrowedP2PUsd: new decimal_js_1.default(borrowedP2P).mul(assetAavePrice).toString(),
+            borrowedPoolUsd: new decimal_js_1.default(borrowedPool).mul(assetAavePrice).toString(),
+            borrowedVariable: borrowed,
+            borrowedUsdVariable: borrowedUsd,
+            isSupplied: new decimal_js_1.default(supplied).gt(0),
+            isBorrowed: new decimal_js_1.default(borrowed).gt(0),
+            supplyRate: new decimal_js_1.default(market.userSupplyRate).div(1e25).toString(),
+            borrowRate: new decimal_js_1.default(market.userBorrowRate).div(1e25).toString(),
+            limit: '0',
+            collateral: true,
+            eModeCategory: 0,
+            interestMode: '',
+            stableBorrowRate: '0',
+            borrowedStable: '0',
+            borrowedUsdStable: '0',
+            stableLimit: '0',
+            variableLimit: '0',
+        };
+    });
+    payload = Object.assign(Object.assign({}, payload), (0, aaveHelpers_1.aaveAnyGetAggregatedPositionData)({
+        usedAssets: payload.usedAssets, assetsData, eModeCategory: 0, selectedMarket: { value: types_1.AaveVersions.MorphoAaveV2 },
+    }));
+    // 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.getMorphoAaveV2AccountData = getMorphoAaveV2AccountData;
+const getMorphoAaveV2FullPositionData = (web3, network, address, ethPrice, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const marketData = yield (0, exports.getMorphoAaveV2MarketsData)(web3, network, ethPrice, mainnetWeb3);
+    const positionData = yield (0, exports.getMorphoAaveV2AccountData)(web3, network, address, marketData.assetsData);
+    return positionData;
+});
+exports.getMorphoAaveV2FullPositionData = getMorphoAaveV2FullPositionData;

package/cjs/morphoAaveV3/index.d.ts

@@ -0,0 +1,7 @@
+import Web3 from 'web3';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+import { MorphoAaveV3AssetsData, MorphoAaveV3MarketData, MorphoAaveV3MarketInfo, MorphoAaveV3PositionData } from '../types';
+export declare const getMorphoAaveV3MarketsData: (web3: Web3, network: NetworkNumber, selectedMarket: MorphoAaveV3MarketInfo, mainnetWeb3: Web3) => Promise<MorphoAaveV3MarketData>;
+export declare const getMorphoAaveV3AccountBalances: (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const getMorphoAaveV3AccountData: (web3: Web3, network: NetworkNumber, address: string, assetsData: MorphoAaveV3AssetsData, delegator: string, selectedMarket: MorphoAaveV3MarketInfo) => Promise<MorphoAaveV3PositionData>;
+export declare const getMorphoAaveV3FullPositionData: (web3: Web3, network: NetworkNumber, address: string, delegator: string, market: MorphoAaveV3MarketInfo, mainnetWeb3: Web3) => Promise<MorphoAaveV3PositionData>;