@defisaver/positions-sdk 0.0.166-dev6-liquity-v2 → 0.0.166-dev6

package/esm/helpers/eulerHelpers/index.js

@@ -0,0 +1,221 @@
+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 __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 { assetAmountInWei } from '@defisaver/tokens';
+import { calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS, } from '../../moneymarket';
+import { calculateInterestEarned } from '../../staking';
+import { EulerV2ViewContract } from '../../contracts';
+import { borrowOperations } from '../../constants';
+import { multicall } from '../../multicall';
+export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
+    let borrowUnstable = 0;
+    let supplyStable = 0;
+    let borrowStable = 0;
+    let supplyUnstable = 0;
+    let longAsset = '';
+    let shortAsset = '';
+    let leverageAssetVault = '';
+    Object.values(usedAssets).forEach(({ symbol, suppliedUsd, borrowedUsd, collateral, vaultAddress, }) => {
+        const isSupplied = (+suppliedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        const isBorrowed = (+borrowedUsd) > dustLimit; // ignore dust like <limit leftover supply
+        if (isSupplied && STABLE_ASSETS.includes(symbol) && collateral)
+            supplyStable += 1;
+        if (isBorrowed && STABLE_ASSETS.includes(symbol))
+            borrowStable += 1;
+        if (isBorrowed && !STABLE_ASSETS.includes(symbol)) {
+            borrowUnstable += 1;
+            shortAsset = symbol;
+            leverageAssetVault = vaultAddress;
+        }
+        if (isSupplied && !STABLE_ASSETS.includes(symbol) && collateral) {
+            supplyUnstable += 1;
+            longAsset = symbol;
+            leverageAssetVault = vaultAddress;
+        }
+    });
+    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,
+            leveragedVault: leverageAssetVault,
+        };
+    }
+    if (isShort) {
+        return {
+            leveragedType: 'short',
+            leveragedAsset: shortAsset,
+            leveragedVault: leverageAssetVault,
+        };
+    }
+    if (isLsdLeveraged) {
+        return {
+            leveragedType: 'lsd-leverage',
+            leveragedAsset: longAsset,
+            leveragedVault: leverageAssetVault,
+        };
+    }
+    return {
+        leveragedType: '',
+        leveragedAsset: '',
+        leveragedVault: '',
+    };
+};
+export const calculateNetApy = (usedAssets, assetsData) => {
+    const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
+        const acc = Object.assign({}, _acc);
+        const assetData = assetsData[usedAsset.vaultAddress.toLowerCase()];
+        if (usedAsset.isSupplied) {
+            const amount = usedAsset.suppliedUsd;
+            acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
+            const rate = assetData.supplyRate;
+            const supplyInterest = calculateInterestEarned(amount, rate, 'year', true);
+            acc.supplyInterest = new Dec(acc.supplyInterest).add(supplyInterest.toString()).toString();
+        }
+        if (usedAsset.isBorrowed) {
+            const amount = usedAsset.borrowedUsd;
+            acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
+            const rate = assetData.borrowRate;
+            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 getEulerV2AggregatedData = (_a) => {
+    var { usedAssets, assetsData, network } = _a, rest = __rest(_a, ["usedAssets", "assetsData", "network"]);
+    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, ({ vaultAddress, suppliedUsd }) => new Dec(suppliedUsd).mul(assetsData[vaultAddress.toLowerCase()].collateralFactor));
+    payload.liquidationLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ vaultAddress, suppliedUsd }) => new Dec(suppliedUsd).mul(assetsData[vaultAddress.toLowerCase()].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.minRatio = '100';
+    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, leveragedVault } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        let assetPrice = assetsData[leveragedVault.toLowerCase()].price;
+        if (leveragedType === 'lsd-leverage') {
+            const ethAsset = Object.values(assetsData).find((asset) => ['WETH', 'ETH'].includes(asset.symbol));
+            if (ethAsset) {
+                payload.leveragedLsdAssetRatio = new Dec(assetsData[leveragedVault.toLowerCase()].price).div(ethAsset.price).toString();
+                assetPrice = new Dec(assetPrice).div(ethAsset.price).toString();
+            }
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    return payload;
+};
+export const getEulerV2BorrowRate = (interestRate) => {
+    const _interestRate = new Dec(interestRate).div(1e27).toString();
+    const secondsPerYear = 31556953;
+    const a = new Dec(1).plus(_interestRate).pow(secondsPerYear - 1).toString();
+    return new Dec(new Dec(a).minus(1)).mul(100).toString();
+};
+export const getUtilizationRate = (totalBorrows, totalAssets) => new Dec(totalBorrows).div(totalAssets).toString();
+export const getEulerV2SupplyRate = (borrowRate, utilizationRate, _interestFee) => {
+    const interestFee = new Dec(_interestFee).div(10000);
+    const fee = new Dec(1).minus(interestFee);
+    return new Dec(borrowRate).mul(utilizationRate).mul(fee).toString();
+};
+const getLiquidityChanges = (action, amount, isBorrowOperation) => {
+    let liquidityAdded;
+    let liquidityRemoved;
+    if (isBorrowOperation) {
+        liquidityAdded = action === 'payback' ? amount : '0';
+        liquidityRemoved = action === 'borrow' ? amount : '0';
+    }
+    else {
+        liquidityAdded = action === 'collateral' ? amount : '0';
+        liquidityRemoved = action === 'withdraw' ? amount : '0';
+    }
+    return { liquidityAdded, liquidityRemoved };
+};
+export const getApyAfterValuesEstimationEulerV2 = (actions, web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const eulerV2ViewContract = EulerV2ViewContract(web3, network);
+    const multicallData = [];
+    const apyAfterValuesEstimationParams = [];
+    actions.forEach(({ action, amount, asset, vaultAddress, }) => {
+        const amountInWei = assetAmountInWei(amount, asset);
+        const isBorrowOperation = borrowOperations.includes(action);
+        const { liquidityAdded, liquidityRemoved } = getLiquidityChanges(action, amountInWei, isBorrowOperation);
+        apyAfterValuesEstimationParams.push([
+            vaultAddress,
+            borrowOperations.includes(action),
+            liquidityAdded,
+            liquidityRemoved,
+        ]);
+        multicallData.push({
+            target: eulerV2ViewContract.options.address,
+            abiItem: eulerV2ViewContract.options.jsonInterface.find(({ name }) => name === 'getVaultInfoFull'),
+            params: [vaultAddress],
+            // @DEV gas usage is HUGE if vault has a lot of collaterals, so be careful, this can break if they add more collaterals
+            gasLimit: 10000000,
+        });
+    });
+    multicallData.push({
+        target: eulerV2ViewContract.options.address,
+        abiItem: eulerV2ViewContract.options.jsonInterface.find(({ name }) => name === 'getApyAfterValuesEstimation'),
+        params: [apyAfterValuesEstimationParams],
+    });
+    const multicallRes = yield multicall(multicallData, web3, network);
+    const numOfActions = actions.length;
+    const data = {};
+    for (let i = 0; i < numOfActions; i += 1) {
+        const _interestRate = multicallRes[numOfActions].estimatedBorrowRates[i];
+        const vaultInfo = multicallRes[i][0];
+        const decimals = vaultInfo.decimals;
+        const borrowRate = getEulerV2BorrowRate(_interestRate);
+        const amount = new Dec(actions[i].amount).mul(Math.pow(10, decimals)).toString();
+        const action = actions[i].action;
+        const isBorrowOperation = borrowOperations.includes(action);
+        const { liquidityAdded, liquidityRemoved } = getLiquidityChanges(action, amount, isBorrowOperation);
+        const totalBorrows = new Dec(vaultInfo.totalBorrows).add(isBorrowOperation ? liquidityRemoved : '0').sub(isBorrowOperation ? liquidityAdded : '0').toString();
+        const totalAssets = new Dec(vaultInfo.totalAssets).add(isBorrowOperation ? '0' : liquidityAdded).sub(isBorrowOperation ? '0' : liquidityRemoved).toString();
+        const utilizationRate = getUtilizationRate(totalBorrows, totalAssets);
+        data[vaultInfo.vaultAddr.toLowerCase()] = {
+            borrowRate,
+            supplyRate: getEulerV2SupplyRate(borrowRate, utilizationRate, vaultInfo.interestFee),
+        };
+    }
+    return data;
+});

package/esm/helpers/index.d.ts

@@ -6,4 +6,4 @@ 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';

package/esm/helpers/index.js

@@ -6,4 +6,4 @@ 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';

package/esm/index.d.ts

@@ -8,7 +8,6 @@ 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';
@@ -19,5 +18,6 @@ import * as chickenBonds from './chickenBonds';
 import * as exchange from './exchange';
 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, liquityV2, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, };
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, };

package/esm/index.js

@@ -8,7 +8,6 @@ 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';
@@ -19,5 +18,6 @@ import * as chickenBonds from './chickenBonds';
 import * as exchange from './exchange';
 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, liquityV2, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, };
+export { aaveV2, aaveV3, morphoAaveV2, morphoAaveV3, compoundV2, compoundV3, spark, curveUsd, liquity, maker, chickenBonds, exchange, staking, multicall, moneymarket, markets, helpers, morphoBlue, llamaLend, eulerV2, };

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

@@ -0,0 +1,8 @@
+import { NetworkNumber } from '../../types/common';
+import { EulerV2Market } from '../../types';
+export declare const eUSDC2: (networkId: NetworkNumber) => EulerV2Market;
+export declare const eWETH2: (networkId: NetworkNumber) => EulerV2Market;
+export declare const EulerV2Markets: (networkId: NetworkNumber) => {
+    readonly "eUSDC-2": EulerV2Market;
+    readonly "eWETH-2": EulerV2Market;
+};

package/esm/markets/euler/index.js

@@ -0,0 +1,24 @@
+import { NetworkNumber } from '../../types/common';
+import { EulerV2Versions } from '../../types';
+export const eUSDC2 = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Euler Prime USDC',
+    shortLabel: 'eUSDC-2',
+    value: EulerV2Versions.eUSDC2,
+    asset: 'USDC',
+    secondLabel: 'Market',
+    marketAddress: '0x797DD80692c3b2dAdabCe8e30C07fDE5307D48a9',
+});
+export const eWETH2 = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Euler Prime WETH',
+    shortLabel: 'eWETH-2',
+    value: EulerV2Versions.eWETH2,
+    asset: 'WETH',
+    secondLabel: 'Market',
+    marketAddress: '0xD8b27CF359b7D15710a5BE299AF6e7Bf904984C2',
+});
+export const EulerV2Markets = (networkId) => ({
+    [EulerV2Versions.eUSDC2]: eUSDC2(networkId),
+    [EulerV2Versions.eWETH2]: eWETH2(networkId),
+});

package/esm/markets/index.d.ts

@@ -4,4 +4,4 @@ export { SparkMarkets } from './spark';
 export { CrvUsdMarkets } from './curveUsd';
 export { MorphoBlueMarkets, findMorphoBlueMarket } from './morphoBlue';
 export { LlamaLendMarkets } from './llamaLend';
-export { LiquityV2Markets } from './liquityV2';
+export { EulerV2Markets } from './euler';

package/esm/markets/index.js

@@ -4,4 +4,4 @@ export { SparkMarkets } from './spark';
 export { CrvUsdMarkets } from './curveUsd';
 export { MorphoBlueMarkets, findMorphoBlueMarket } from './morphoBlue';
 export { LlamaLendMarkets } from './llamaLend';
-export { LiquityV2Markets } from './liquityV2';
+export { EulerV2Markets } from './euler';

package/esm/moneymarket/moneymarketCommonService.js

@@ -16,7 +16,7 @@ export const calcLeverageLiqPrice = (leverageType, assetPrice, borrowedUsd, borr
     return '0';
 };
 export const calculateBorrowingAssetLimit = (assetBorrowedUsd, borrowLimitUsd) => new Dec(assetBorrowedUsd).div(borrowLimitUsd).times(100).toString();
-export const STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI', 'crvUSD', 'BOLD'];
+export const STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI', 'crvUSD'];
 export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
     let borrowUnstable = 0;
     let supplyStable = 0;

package/esm/services/utils.d.ts

@@ -20,3 +20,5 @@ export declare const bytesToString: (hex: string) => string;
  */
 export declare const mapRange: (input: number | string, minInput: number | string, maxInput: number | string, minOutput: number | string, maxOutput: number | string) => number;
 export declare const isEnabledOnBitmap: (bitmap: number, assetId: number) => bigint;
+export declare const MAXUINT: string;
+export declare const isMaxuint: (amount: string) => boolean;

package/esm/services/utils.js

@@ -33,3 +33,5 @@ export const mapRange = (input, minInput, maxInput, minOutput, maxOutput) => {
 };
 // eslint-disable-next-line no-bitwise
 export const isEnabledOnBitmap = (bitmap, assetId) => (BigInt(bitmap) >> BigInt(assetId)) & BigInt(1);
+export const MAXUINT = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+export const isMaxuint = (amount) => compareAddresses(MAXUINT, amount);

package/esm/staking/staking.js

@@ -82,7 +82,6 @@ export const getSsrApy = () => __awaiter(void 0, void 0, void 0, function* () {
     return new Dec(data.data.skyData[0].sky_savings_rate_apy).mul(100).toString();
 });
 const getSuperOETHApy = () => __awaiter(void 0, void 0, void 0, function* () {
-    console.log('getSuperOETHApy');
     const res = yield fetch('https://origin.squids.live/origin-squid/graphql', {
         method: 'POST',
         headers: {
@@ -106,7 +105,6 @@ const getApyFromDfsApi = (asset) => __awaiter(void 0, void 0, void 0, function*
 });
 export const STAKING_ASSETS = ['cbETH', 'wstETH', 'cbETH', 'rETH', 'sDAI', 'weETH', 'sUSDe', 'osETH', 'ezETH', 'ETHx', 'rsETH', 'pufETH', 'wrsETH', 'wsuperOETHb', 'sUSDS'];
 export const getStakingApy = (asset, web3, blockNumber = 'latest', fromBlock = undefined) => {
-    console.log('getStakingApy', asset, blockNumber, fromBlock);
     try {
         if (asset === 'stETH' || asset === 'wstETH')
             return getStETHApr(web3, fromBlock, blockNumber);