@defisaver/ethena-sdk 0.0.2 → 0.0.4

package/cjs/services/viem.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getViemProvider = exports.getViemChain = void 0;
+const positions_sdk_1 = require("@defisaver/positions-sdk");
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const getViemChain = (network) => {
+    switch (network) {
+        case positions_sdk_1.NetworkNumber.Eth:
+            return chains_1.mainnet;
+        case positions_sdk_1.NetworkNumber.Opt:
+            return chains_1.optimism;
+        case positions_sdk_1.NetworkNumber.Arb:
+            return chains_1.arbitrum;
+        case positions_sdk_1.NetworkNumber.Base:
+            return chains_1.base;
+        case positions_sdk_1.NetworkNumber.Linea:
+            return chains_1.linea;
+        case positions_sdk_1.NetworkNumber.Plasma:
+            return chains_1.plasma;
+        default:
+            throw new Error(`Unsupported network: ${network}`);
+    }
+};
+exports.getViemChain = getViemChain;
+const getViemProvider = (rpcUrl, network, options) => (0, viem_1.createPublicClient)(Object.assign({ transport: (0, viem_1.http)(rpcUrl), chain: (0, exports.getViemChain)(network) }, options));
+exports.getViemProvider = getViemProvider;

package/cjs/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/setup.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const decimal_js_1 = __importDefault(require("decimal.js"));
+decimal_js_1.default.set({
+    rounding: decimal_js_1.default.ROUND_DOWN,
+    toExpPos: 9e15,
+    toExpNeg: -9e15,
+    precision: 50,
+});

package/cjs/types/common.d.ts

@@ -0,0 +1,24 @@
+import { IncentiveData, MMUsedAssets, MorphoBlueAggregatedPositionData, NetworkNumber } from '@defisaver/positions-sdk';
+import { SupportedMarkets } from './markets';
+export interface AssetData {
+    symbol: string;
+    address: string;
+    supplyRate: string;
+    borrowRate: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
+    isDebtAsset: boolean;
+}
+export interface MarketData {
+    market: SupportedMarkets;
+    maxLeverage: number;
+    assetsData: Record<string, AssetData>;
+    maxApy: string;
+    leftToBorrowGlobal: string;
+    lltv: string;
+    rate: string;
+}
+export interface PositionData extends MorphoBlueAggregatedPositionData {
+    usedAssets: MMUsedAssets;
+}
+export { NetworkNumber, MMUsedAssets, IncentiveData, };

package/cjs/types/common.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkNumber = void 0;
+const positions_sdk_1 = require("@defisaver/positions-sdk");
+Object.defineProperty(exports, "NetworkNumber", { enumerable: true, get: function () { return positions_sdk_1.NetworkNumber; } });

package/cjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './markets';

package/cjs/types/index.js

@@ -0,0 +1,18 @@
+"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("./common"), exports);
+__exportStar(require("./markets"), exports);

package/cjs/types/markets.d.ts

@@ -0,0 +1,3 @@
+export declare enum SupportedMarkets {
+    MorphoBlueSUSDeUSDtb_915 = "morphobluesusdeusdtb_915"
+}

package/cjs/types/markets.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedMarkets = void 0;
+var SupportedMarkets;
+(function (SupportedMarkets) {
+    SupportedMarkets["MorphoBlueSUSDeUSDtb_915"] = "morphobluesusdeusdtb_915";
+})(SupportedMarkets || (exports.SupportedMarkets = SupportedMarkets = {}));

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+import './setup';
+import * as positionData from './positionData';
+import * as marketData from './marketData';
+export * from './types';
+export { positionData, marketData, };

package/esm/index.js

@@ -0,0 +1,5 @@
+import './setup';
+import * as positionData from './positionData';
+import * as marketData from './marketData';
+export * from './types';
+export { positionData, marketData, };

package/esm/marketData/index.d.ts

@@ -0,0 +1,4 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { MarketData, SupportedMarkets } from '../types';
+export declare const getMarketData: (market: SupportedMarkets, rpcUrl: string, network: NetworkNumber) => Promise<MarketData>;
+export declare const getNetApy: (marketData: MarketData, leverage: number) => string;

package/esm/marketData/index.js

@@ -0,0 +1,29 @@
+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 { SupportedMarkets } from '../types';
+import { getMorphoMarketData, getMorphoNetApy, } from './morpho';
+export const getMarketData = (market, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    switch (market) {
+        case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return getMorphoMarketData(market, rpcUrl, network);
+        }
+        default:
+            throw new Error(`Unsupported market: ${market}`);
+    }
+});
+export const getNetApy = (marketData, leverage) => {
+    switch (marketData.market) {
+        case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return getMorphoNetApy(marketData, leverage);
+        }
+        default:
+            throw new Error(`Unsupported market: ${marketData.market}`);
+    }
+};

package/esm/marketData/morpho.d.ts

@@ -0,0 +1,4 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { MarketData, SupportedMarkets } from '../types';
+export declare const getMorphoMarketData: (market: SupportedMarkets, rpcUrl: string, network: NetworkNumber) => Promise<MarketData>;
+export declare const getMorphoNetApy: (marketData: MarketData, leverage: number) => string;

package/esm/marketData/morpho.js

@@ -0,0 +1,68 @@
+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 { helpers, markets, morphoBlue, MorphoBlueVersions, } from '@defisaver/positions-sdk';
+import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
+import { getViemProvider } from '../services/viem';
+const getMaxLeverage = (collateralFactor) => new Dec(1)
+    .div(new Dec(1).sub(collateralFactor))
+    .toDP(2).toString();
+const scaleMaxLeverage = (leverage) => leverage * 0.9;
+const getLevApy = (leverage, supplyAsset, borrowAsset) => {
+    const supplyRate = new Dec(supplyAsset.supplyRate).add(supplyAsset.supplyIncentives.reduce((acc, curr) => acc.add(curr.apy), new Dec(0)));
+    const borrowRate = new Dec(borrowAsset.borrowRate).add(borrowAsset.borrowIncentives.reduce((acc, curr) => acc.add(curr.apy), new Dec(0)));
+    return new Dec(leverage).mul(supplyRate)
+        .sub(new Dec(leverage).sub(1).mul(borrowRate))
+        .toDP(4)
+        .toString();
+};
+const formatAssetsData = (assetsData) => {
+    const formattedData = {};
+    Object.entries(assetsData).forEach(([assetSymbol, assetData]) => {
+        formattedData[assetSymbol] = {
+            symbol: assetData.symbol,
+            address: assetData.address,
+            supplyRate: assetData.supplyRate,
+            borrowRate: assetData.borrowRate,
+            supplyIncentives: assetData.supplyIncentives,
+            borrowIncentives: assetData.borrowIncentives,
+            isDebtAsset: assetData.canBeBorrowed,
+        };
+    });
+    return formattedData;
+};
+export const getMorphoMarketData = (market, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = getViemProvider(rpcUrl, network);
+    const morphoMarket = markets.MorphoBlueMarkets(network)[MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915];
+    const [marketData, { reallocatableLiquidity: availableLiquidityWei }] = yield Promise.all([
+        morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket),
+        helpers.morphoBlueHelpers.getReallocatableLiquidity(morphoMarket.marketId, network),
+    ]);
+    const maxLeverageFactor = getMaxLeverage(marketData.lltv);
+    const scaledMaxLeverage = scaleMaxLeverage(parseFloat(maxLeverageFactor));
+    const assetsData = formatAssetsData(marketData.assetsData);
+    const availableLiquidity = assetAmountInEth(availableLiquidityWei, 'USDtb');
+    const leftToBorrowGlobal = new Dec(marketData.assetsData.USDtb.totalSupply || '0').sub(marketData.assetsData.USDtb.totalBorrow || '0').toString();
+    const leftToBorrowGlobalAdjusted = new Dec(availableLiquidity).add(leftToBorrowGlobal).toString();
+    return {
+        market,
+        maxLeverage: scaledMaxLeverage,
+        assetsData,
+        maxApy: getLevApy(scaledMaxLeverage, assetsData.sUSDe, assetsData.USDtb),
+        leftToBorrowGlobal: leftToBorrowGlobalAdjusted,
+        lltv: marketData.lltv,
+        rate: marketData.oracle,
+    };
+});
+export const getMorphoNetApy = (marketData, leverage) => {
+    const supplyAsset = Object.values(marketData.assetsData).find((asset) => !asset.isDebtAsset);
+    const borrowAsset = Object.values(marketData.assetsData).find((asset) => asset.isDebtAsset);
+    return getLevApy(leverage, supplyAsset, borrowAsset);
+};

package/esm/positionData/index.d.ts

@@ -0,0 +1,3 @@
+import { MarketData, NetworkNumber, PositionData } from '../types';
+export declare const getMaxLeverageForSupplyAmount: (marketData: MarketData, supplyAmount: string) => number;
+export declare const getResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/index.js

@@ -0,0 +1,29 @@
+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 { SupportedMarkets, } from '../types';
+import { getMorphoMaxLeverageForSupplyAmount, getMorphoResultingPosition } from './morpho';
+export const getMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
+    switch (marketData.market) {
+        case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return getMorphoMaxLeverageForSupplyAmount(marketData, supplyAmount);
+        }
+        default:
+            throw new Error(`Unsupported market: ${marketData.market}`);
+    }
+};
+export const getResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    switch (marketData.market) {
+        case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return getMorphoResultingPosition(marketData, supplyAmount, leverage, rpcUrl, network);
+        }
+        default:
+            throw new Error(`Unsupported market: ${marketData.market}`);
+    }
+});

package/esm/positionData/morpho.d.ts

@@ -0,0 +1,4 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { MarketData, PositionData } from '../types';
+export declare const getMorphoMaxLeverageForSupplyAmount: (marketData: MarketData, supplyAmount: string) => number;
+export declare const getMorphoResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/morpho.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { getAssetInfo } from '@defisaver/tokens';
+import { helpers, markets, morphoBlue, MorphoBlueVersions, } from '@defisaver/positions-sdk';
+import { getViemProvider } from '../services/viem';
+const getMaxBoostUsd = (lltv, borrowLimit, debt, targetRatio = 1.01, bufferPercent = 1) => new Dec(targetRatio).mul(debt).sub(borrowLimit)
+    .div(new Dec(lltv).sub(targetRatio).toString())
+    .mul((100 - bufferPercent) / 100)
+    .toString();
+const getMorphoMaxLeverageBorrow = (marketData, supplyAmount) => {
+    const { lltv, rate: oracle, assetsData, leftToBorrowGlobal, } = marketData;
+    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
+    const maxBorrow = new Dec(supplyAmount).mul(oracle).mul(lltv).toString();
+    const maxBoost = getMaxBoostUsd(lltv, maxBorrow, '0');
+    return Dec.min(Dec.max(0, maxBoost), leftToBorrowGlobal).toDP(getAssetInfo(borrowAsset === null || borrowAsset === void 0 ? void 0 : borrowAsset.symbol).decimals).toString();
+};
+export const getMorphoMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
+    // TODO: implement FL logic
+    const feeMultiplier = 1;
+    const maxDebt = new Dec(getMorphoMaxLeverageBorrow(marketData, supplyAmount)).div(feeMultiplier).toString();
+    const rate = new Dec(1).div(marketData.rate).toString();
+    const maxLeverage = new Dec(supplyAmount).plus(new Dec(maxDebt).times(rate)).div(supplyAmount).toNumber();
+    return maxLeverage;
+};
+export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = getViemProvider(rpcUrl, network);
+    const morphoMarket = markets.MorphoBlueMarkets(network)[MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915];
+    const { rate: oracle, assetsData, } = marketData;
+    const debtAmount = new Dec(leverage)
+        .times(supplyAmount).minus(supplyAmount).times(oracle)
+        .toString();
+    // TODO: add price fetching logic
+    const priceForAmount = new Dec(1).div(oracle).toString();
+    const leveragedAmount = new Dec(debtAmount).times(priceForAmount);
+    const collIncrease = new Dec(supplyAmount).plus(leveragedAmount).toString();
+    const supplyAsset = Object.values(assetsData).find((asset) => !asset.isDebtAsset);
+    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
+    const morphoMarketData = yield morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket);
+    const usedAssets = {};
+    usedAssets[borrowAsset.symbol] = {
+        symbol: borrowAsset.symbol,
+        supplied: '0',
+        borrowed: debtAmount,
+        isSupplied: false,
+        isBorrowed: true,
+        collateral: false,
+        suppliedUsd: '0',
+        borrowedUsd: new Dec(debtAmount).mul(morphoMarketData.assetsData[borrowAsset.symbol].price).toString(),
+    };
+    usedAssets[supplyAsset.symbol] = {
+        symbol: supplyAsset.symbol,
+        supplied: collIncrease,
+        borrowed: '0',
+        isSupplied: true,
+        isBorrowed: false,
+        collateral: true,
+        suppliedUsd: new Dec(collIncrease).mul(morphoMarketData.assetsData[supplyAsset.symbol].price).toString(),
+        borrowedUsd: '0',
+    };
+    const aggregatedPosition = helpers.morphoBlueHelpers.getMorphoBlueAggregatedPositionData({ usedAssets, assetsData: morphoMarketData.assetsData, marketInfo: morphoMarketData });
+    return Object.assign({ usedAssets }, aggregatedPosition);
+});