@defisaver/ethena-sdk 0.0.1

package/.env.example

@@ -0,0 +1 @@
+RPC=

package/.eslintrc.js

@@ -0,0 +1,34 @@
+
+module.exports = {
+  extends: ['@defisaver/eslint-config/base-config'],
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+  },
+  env: {
+    es6: true,
+    browser: true,
+    mocha: true,
+  },
+  ignorePatterns: ['esm/', 'cjs/'],
+  overrides: [{
+    files: ['*.ts', '*.tsx'],
+    extends: ['@defisaver/eslint-config/base-config-typescript'],
+    parser: '@typescript-eslint/parser',
+    parserOptions: { project: ['./tsconfig.json'] },
+  }],
+  rules: {
+    'max-len': 0,
+  },
+  settings: {
+    // 'import/resolver': {
+    //   node: {
+    //     extensions: ['.js', '.ts'],
+    //   },
+    //   typescript: {
+    //     alwaysTryTypes: true,
+    //     project: ['./tsconfig.json'],
+    //   },
+    // },
+  },
+};

package/.mocharc.json

@@ -0,0 +1,4 @@
+{
+    "require": "ts-node/register",
+    "extension": ["ts"]
+}

package/.nvmrc

@@ -0,0 +1 @@
+v20.17.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeFi Saver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@defisaver/ethena-sdk",
+  "version": "0.0.1",
+  "description": "SDK for ethena lev create",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./esm/index.d.ts",
+  "scripts": {
+    "build:esm": "rm -rf esm && tsc -p tsconfig.esm.json",
+    "build:cjs": "rm -rf cjs && tsc -p tsconfig.cjs.json",
+    "build": "npm run lint && npm run build:cjs && npm run build:esm",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint src/ --fix",
+    "lint-check": "eslint src/",
+    "test": "mocha tests/*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/defisaver/ethena-sdk.git"
+  },
+  "author": "DeFi Saver",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/defisaver/ethena-sdk/issues"
+  },
+  "homepage": "https://github.com/defisaver/ethena-sdk#readme",
+  "dependencies": {
+    "@defisaver/positions-sdk": "^2.1.57",
+    "@defisaver/tokens": "^1.7.22",
+    "@types/lodash": "^4.17.15",
+    "@types/memoizee": "^0.4.12",
+    "decimal.js": "^10.6.0",
+    "lodash": "^4.17.21",
+    "memoizee": "^0.4.17",
+    "viem": "^2.37.9"
+  },
+  "devDependencies": {
+    "@defisaver/eslint-config": "^1.0.1",
+    "@metamask/eth-json-rpc-middleware": "^15.0.1",
+    "@metamask/eth-json-rpc-provider": "^4.1.6",
+    "@types/chai": "^5.0.0",
+    "@types/mocha": "^10.0.9",
+    "chai": "^4.3.8",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.49.0",
+    "eslint-plugin-import": "^2.31.0",
+    "mocha": "^10.2.0",
+    "nock": "^14.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.2.2"
+  }
+}

package/src/index.ts

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

package/src/marketData/index.ts

@@ -0,0 +1,25 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { MarketData, PositionData, SupportedMarkets } from '../types';
+import {
+  getMorphoMarketData, getMorphoNetApy,
+} from './morpho';
+
+export const getMarketData = async (market: SupportedMarkets, rpcUrl: string, network: NetworkNumber): Promise<MarketData> => {
+  switch (market) {
+    case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+      return getMorphoMarketData(market, rpcUrl, network);
+    }
+    default:
+      throw new Error(`Unsupported market: ${market}`);
+  }
+};
+
+export const getNetApy = (marketData: MarketData, leverage: number) => {
+  switch (marketData.market) {
+    case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+      return getMorphoNetApy(marketData, leverage);
+    }
+    default:
+      throw new Error(`Unsupported market: ${marketData.market}`);
+  }
+};

package/src/marketData/morpho.ts

@@ -0,0 +1,75 @@
+import {
+  helpers, markets, morphoBlue, MorphoBlueVersions, NetworkNumber,
+} from '@defisaver/positions-sdk';
+import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
+import {
+  AssetData, MarketData, SupportedMarkets,
+} from '../types';
+import { getViemProvider } from '../services/viem';
+
+const getMaxLeverage = (collateralFactor: string) => new Dec(1)
+  .div(new Dec(1).sub(collateralFactor))
+  .toDP(2).toString();
+
+const scaleMaxLeverage = (leverage: number) => leverage * 0.9;
+
+const getLevApy = (leverage: number, supplyAsset: AssetData, borrowAsset: AssetData) => {
+  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: Record<string, any>): Record<string, AssetData> => {
+  const formattedData: Record<string, any> = {};
+  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 = async (market: SupportedMarkets, rpcUrl: string, network: NetworkNumber): Promise<MarketData> => {
+  const provider = getViemProvider(rpcUrl, network);
+
+  const morphoMarket = markets.MorphoBlueMarkets(network)[MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915];
+  const [marketData, { reallocatableLiquidity: availableLiquidityWei }] = await 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: MarketData, leverage: number) => {
+  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/src/positionData/index.ts

@@ -0,0 +1,24 @@
+import {
+  MarketData, NetworkNumber, PositionData, SupportedMarkets,
+} from '../types';
+import { getMorphoMaxLeverageForSupplyAmount, getMorphoResultingPosition } from './morpho';
+
+export const getMaxLeverageForSupplyAmount = (marketData: MarketData, supplyAmount: string) => {
+  switch (marketData.market) {
+    case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+      return getMorphoMaxLeverageForSupplyAmount(marketData, supplyAmount);
+    }
+    default:
+      throw new Error(`Unsupported market: ${marketData.market}`);
+  }
+};
+
+export const getResultingPosition = async (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber): Promise<PositionData> => {
+  switch (marketData.market) {
+    case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+      return getMorphoResultingPosition(marketData, supplyAmount, leverage, rpcUrl, network);
+    }
+    default:
+      throw new Error(`Unsupported market: ${marketData.market}`);
+  }
+};

package/src/positionData/morpho.ts

@@ -0,0 +1,90 @@
+import Dec from 'decimal.js';
+import { getAssetInfo } from '@defisaver/tokens';
+import {
+  helpers, markets, MMUsedAssets, morphoBlue, MorphoBlueVersions, NetworkNumber,
+} from '@defisaver/positions-sdk';
+import { AssetData, MarketData, PositionData } from '../types';
+import { getViemProvider } from '../services/viem';
+
+const getMaxBoostUsd = (lltv: string, borrowLimit: string, debt: string, 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: MarketData, supplyAmount: string) => {
+  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?.symbol).decimals).toString();
+};
+
+export const getMorphoMaxLeverageForSupplyAmount = (marketData: MarketData, supplyAmount: string) => {
+  // 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 = async (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber): Promise<PositionData> => {
+  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: AssetData = Object.values(assetsData).find((asset) => !asset.isDebtAsset)!;
+  const borrowAsset: AssetData = Object.values(assetsData).find((asset) => asset.isDebtAsset)!;
+
+  const morphoMarketData = await morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket);
+  const usedAssets: MMUsedAssets = {};
+
+  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 {
+    usedAssets,
+    ...aggregatedPosition,
+  };
+};

package/src/services/viem.ts

@@ -0,0 +1,33 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import {
+  createPublicClient,
+  http,
+} from 'viem';
+import {
+  arbitrum, base, mainnet, optimism, linea, plasma,
+} from 'viem/chains';
+
+export const getViemChain = (network: NetworkNumber) => {
+  switch (network) {
+    case NetworkNumber.Eth:
+      return mainnet;
+    case NetworkNumber.Opt:
+      return optimism;
+    case NetworkNumber.Arb:
+      return arbitrum;
+    case NetworkNumber.Base:
+      return base;
+    case NetworkNumber.Linea:
+      return linea;
+    case NetworkNumber.Plasma:
+      return plasma;
+    default:
+      throw new Error(`Unsupported network: ${network}`);
+  }
+};
+
+export const getViemProvider = (rpcUrl: string, network: NetworkNumber, options?: any) => createPublicClient({
+  transport: http(rpcUrl),
+  chain: getViemChain(network),
+  ...options,
+});

package/src/setup.ts

@@ -0,0 +1,8 @@
+import Decimal from 'decimal.js';
+
+Decimal.set({
+  rounding: Decimal.ROUND_DOWN,
+  toExpPos: 9e15,
+  toExpNeg: -9e15,
+  precision: 50,
+});

package/src/types/common.ts

@@ -0,0 +1,34 @@
+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/src/types/index.ts

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

package/src/types/markets.ts

@@ -0,0 +1,5 @@
+import { MorphoBlueVersions } from '@defisaver/positions-sdk';
+
+export enum SupportedMarkets {
+  MorphoBlueSUSDeUSDtb_915 = MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915,
+}

package/tests/morpho.ts

@@ -0,0 +1,51 @@
+import 'dotenv/config';
+
+import {
+  marketData, NetworkNumber, positionData, SupportedMarkets,
+} from '../src';
+
+const { assert } = require('chai');
+
+
+describe('Tests', () => {
+  let rpcUrl: string;
+
+  before(async () => {
+    rpcUrl = process.env.RPC || '';
+  });
+
+  it('can fetch morpho sUSDe/USDtb market data', async function () {
+    this.timeout(10000);
+    const network = NetworkNumber.Eth;
+    const selectedMarket = SupportedMarkets.MorphoBlueSUSDeUSDtb_915;
+
+    const market = await marketData.getMarketData(selectedMarket, rpcUrl, network);
+  });
+
+  it('can fetch morpho sUSDe/USDtb apy for 4x exposure', async function () {
+    this.timeout(10000);
+    const network = NetworkNumber.Eth;
+    const selectedMarket = SupportedMarkets.MorphoBlueSUSDeUSDtb_915;
+
+    const market = await marketData.getMarketData(selectedMarket, rpcUrl, network);
+    const apy = marketData.getNetApy(market, 4);
+  });
+
+  it('can fetch morpho sUSDe/USDtb max exposure for 100000 supply', async function () {
+    this.timeout(10000);
+    const network = NetworkNumber.Eth;
+    const selectedMarket = SupportedMarkets.MorphoBlueSUSDeUSDtb_915;
+
+    const market = await marketData.getMarketData(selectedMarket, rpcUrl, network);
+    const maxLeverage = positionData.getMaxLeverageForSupplyAmount(market, '100000');
+  });
+
+  it('can fetch morpho sUSDe/USDtb resulting position for 100000 supply and 4x exposure', async function () {
+    this.timeout(10000);
+    const network = NetworkNumber.Eth;
+    const selectedMarket = SupportedMarkets.MorphoBlueSUSDeUSDtb_915;
+
+    const market = await marketData.getMarketData(selectedMarket, rpcUrl, network);
+    const position = await positionData.getResultingPosition(market, '100000', 4, rpcUrl, network);
+  });
+});

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "exclude": [
+      "tests/**/*"
+    ]
+  }
+  

package/tsconfig.esm.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": "./esm/"
+  },
+  "exclude": [
+    "tests/**/*"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "node16",
+    "moduleResolution": "node16",
+    "outDir": "./cjs/",
+    "target": "ES2015",
+    "allowJs": true,
+    "declaration": true,
+    "strict": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "./src/*",
+    "./tests/**/*.ts"
+  ],
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "out": "docs"
+  }
+}