@defisaver/ethena-sdk 0.0.4 → 0.0.5

package/cjs/constants/index.d.ts

@@ -0,0 +1,4 @@
+export declare const STABLE_PAIR_FEE_DIVIDER = "10000";
+export declare const DFS_API_URL = "https://fe.defisaver.com";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const SLIPPAGE_PERCENT = 0.05;

package/cjs/constants/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLIPPAGE_PERCENT = exports.ZERO_ADDRESS = exports.DFS_API_URL = exports.STABLE_PAIR_FEE_DIVIDER = void 0;
+exports.STABLE_PAIR_FEE_DIVIDER = '10000';
+exports.DFS_API_URL = 'https://fe.defisaver.com';
+exports.ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+exports.SLIPPAGE_PERCENT = 0.05;

package/cjs/exchange/index.d.ts

@@ -0,0 +1,10 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { OffchainExchanges, PriceData } from '../types';
+export declare const numStringToBytes: (num: number) => string;
+export declare const getBestPrice: (fromAsset: string, toAsset: string, amount: string, userAddress: string, network?: NetworkNumber) => Promise<PriceData>;
+export declare const getExchangeOrder: (fromAsset: string, toAsset: string, amount: string, userAddress: string, minPrice: string, network?: NetworkNumber) => Promise<{
+    orderData: (string | string[])[];
+    value: string;
+    source: OffchainExchanges | "None";
+    price: string;
+}>;

package/cjs/exchange/index.js

@@ -0,0 +1,185 @@
+"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.getExchangeOrder = exports.getBestPrice = exports.numStringToBytes = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const positions_sdk_1 = require("@defisaver/positions-sdk");
+const tokens_1 = require("@defisaver/tokens");
+const types_1 = require("../types");
+const constants_1 = require("../constants");
+const getOffchainEmptyData = (source = 'None') => ({
+    wrapper: constants_1.ZERO_ADDRESS,
+    to: constants_1.ZERO_ADDRESS,
+    allowanceTarget: constants_1.ZERO_ADDRESS,
+    price: '0',
+    priceWithFee: '0',
+    protocolFee: '0',
+    data: '0x00',
+    value: '0',
+    gas: '0',
+    source,
+});
+const parsePriceWithDecimals = (price, fromDecimals, toDecimals) => new decimal_js_1.default(price)
+    .div(Math.pow(10, toDecimals))
+    .div(Math.pow(10, (18 - fromDecimals)))
+    .toString();
+const formatPriceWithDecimalForContract = (price, fromDecimals, toDecimals) => new decimal_js_1.default(price)
+    .mul(Math.pow(10, toDecimals))
+    .mul(Math.pow(10, (18 - fromDecimals)))
+    .floor()
+    .toString();
+const includeFeeInPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new decimal_js_1.default(price).mul(new decimal_js_1.default(1).sub(fee)).toString();
+};
+const excludeFeeFromPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new decimal_js_1.default(price).mul(new decimal_js_1.default(1).add(fee)).toString();
+};
+const parseOffchainPrice = (fromTokenSymbol, fromTokenDecimals, toTokenSymbol, toTokenDecimals, amount, feeDecimal) => {
+    const _price = parsePriceWithDecimals(amount, fromTokenDecimals, toTokenDecimals);
+    return includeFeeInPrice(_price, fromTokenSymbol, toTokenSymbol, feeDecimal);
+};
+const getFeeDecimal = () => new decimal_js_1.default(1).div(constants_1.STABLE_PAIR_FEE_DIVIDER).toString();
+const numStringToBytes = (num) => {
+    const bn = new bn_js_1.default(num.toString()).toTwos(256);
+    return bn.toString(16);
+};
+exports.numStringToBytes = numStringToBytes;
+const getPriceFromServer = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = positions_sdk_1.NetworkNumber.Eth, infoOnly = true) {
+    const fromAssetData = (0, tokens_1.getAssetInfo)(fromAsset, network);
+    const toAssetData = (0, tokens_1.getAssetInfo)(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const excludedSources = ['Balancer_V2', 'Beethovenx'];
+    const allSources = Object.values(types_1.OffchainExchanges);
+    try {
+        const res = yield fetch(`${constants_1.DFS_API_URL}/api/exchange/get-best-price`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                fromAsset: fromAssetData.address,
+                fromAssetDecimals: fromAssetData.decimals,
+                fromAssetSymbol: fromAssetData.symbol,
+                toAsset: toAssetData.address,
+                toAssetDecimals: toAssetData.decimals,
+                toAssetSymbol: toAssetData.symbol,
+                sources: [...allSources.map(s => s.toLowerCase())],
+                chainId: network,
+                amount,
+                excludedSources,
+                infoOnly,
+                takerAddress: userAddress,
+                account: userAddress,
+                noFee: false,
+                feeDecimal,
+                // temporary fix for paraswap until old exchange service is removed
+                shouldFormatParaswapPrice: true,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        const formattedData = data.map((d, i) => {
+            const source = allSources[i];
+            if (typeof d === 'string')
+                return getOffchainEmptyData(source);
+            return {
+                wrapper: d.wrapper || constants_1.ZERO_ADDRESS,
+                to: d.to || constants_1.ZERO_ADDRESS,
+                allowanceTarget: d.allowanceTarget || constants_1.ZERO_ADDRESS,
+                protocolFee: d.protocolFee || '0',
+                data: d.data || '0x00',
+                value: d.value || '0',
+                gas: d.gas || '0',
+                source: allSources[i],
+                price: d.price,
+                priceWithFee: +(d.price || '0') > 0
+                    ? parseOffchainPrice(fromAssetData.symbol, fromAssetData.decimals, toAssetData.symbol, toAssetData.decimals, d.price, feeDecimal)
+                    : '0',
+            };
+        }).filter((d) => d.wrapper !== constants_1.ZERO_ADDRESS && d.price !== '0').sort((a, b) => (new decimal_js_1.default(a.price).gt(b.price) ? -1 : 1));
+        return formattedData;
+    }
+    catch (_a) {
+        return allSources.map(source => getOffchainEmptyData(source));
+    }
+});
+const getBestPrice = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = positions_sdk_1.NetworkNumber.Eth) {
+    try {
+        const formattedData = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network);
+        return formattedData[0] || getOffchainEmptyData();
+    }
+    catch (e) {
+        console.error('Error fetching best price:', e);
+        return getOffchainEmptyData();
+    }
+});
+exports.getBestPrice = getBestPrice;
+const getExchangeOrder = (fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, minPrice, network = positions_sdk_1.NetworkNumber.Eth) {
+    const fromAssetData = (0, tokens_1.getAssetInfo)(fromAsset, network);
+    const toAssetData = (0, tokens_1.getAssetInfo)(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const offchainQuotes = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network, false);
+    const formattedOffchainQuotes = offchainQuotes.map((quote) => ({
+        source: quote.source,
+        price: quote.priceWithFee,
+        wrapper: quote.wrapper,
+        wrapperData: quote.data,
+        offchainData: quote,
+    }));
+    const bestQuote = formattedOffchainQuotes[0];
+    const { offchainData, source, price } = bestQuote;
+    const minPriceFormatted = new decimal_js_1.default(excludeFeeFromPrice(minPrice, fromAssetData.address, toAssetData.address, feeDecimal))
+        .mul(100 - constants_1.SLIPPAGE_PERCENT)
+        .div(100)
+        .toString();
+    const minPriceForContract = formatPriceWithDecimalForContract(minPriceFormatted, fromAssetData.decimals, toAssetData.decimals);
+    const offchainDataArray = [
+        offchainData.wrapper,
+        offchainData.to,
+        offchainData.allowanceTarget,
+        offchainData.price,
+        offchainData.protocolFee,
+        offchainData.data,
+    ];
+    const value = offchainData.protocolFee;
+    const wrapper = constants_1.ZERO_ADDRESS;
+    const wrapperData = `0x${(0, exports.numStringToBytes)(Math.floor(Date.now() / 1000))}`;
+    const amountWei = (0, tokens_1.assetAmountInWei)(amount, fromAsset).toString();
+    if (offchainData.data === '0x00')
+        throw new Error('Offchain data is empty');
+    return {
+        orderData: [
+            fromAssetData.address,
+            toAssetData.address,
+            amountWei,
+            '0',
+            minPriceForContract,
+            constants_1.STABLE_PAIR_FEE_DIVIDER,
+            '0x0000000000000000000000000000000000000000', // set by contract
+            wrapper,
+            wrapperData,
+            offchainDataArray,
+        ],
+        value,
+        source,
+        price,
+    };
+});
+exports.getExchangeOrder = getExchangeOrder;

package/cjs/index.d.ts

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

package/cjs/index.js

@@ -36,10 +36,14 @@ 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 });
-exports.marketData = exports.positionData = void 0;
+exports.constants = exports.exchange = exports.marketData = exports.positionData = void 0;
 require("./setup");
 const positionData = __importStar(require("./positionData"));
 exports.positionData = positionData;
 const marketData = __importStar(require("./marketData"));
 exports.marketData = marketData;
+const exchange = __importStar(require("./exchange"));
+exports.exchange = exchange;
+const constants = __importStar(require("./constants"));
+exports.constants = constants;
 __exportStar(require("./types"), exports);

package/cjs/positionData/index.d.ts

@@ -1,3 +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>;
+export declare const getResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/cjs/positionData/index.js

@@ -22,10 +22,10 @@ const getMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
     }
 };
 exports.getMaxLeverageForSupplyAmount = getMaxLeverageForSupplyAmount;
-const getResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+const getResultingPosition = (marketData, supplyAmount, leverage, userAddress, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
     switch (marketData.market) {
         case types_1.SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
-            return (0, morpho_1.getMorphoResultingPosition)(marketData, supplyAmount, leverage, rpcUrl, network);
+            return (0, morpho_1.getMorphoResultingPosition)(marketData, supplyAmount, leverage, userAddress, rpcUrl, network);
         }
         default:
             throw new Error(`Unsupported market: ${marketData.market}`);

package/cjs/positionData/morpho.d.ts

@@ -1,4 +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>;
+export declare const getMorphoResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/cjs/positionData/morpho.js

@@ -17,6 +17,7 @@ const decimal_js_1 = __importDefault(require("decimal.js"));
 const tokens_1 = require("@defisaver/tokens");
 const positions_sdk_1 = require("@defisaver/positions-sdk");
 const viem_1 = require("../services/viem");
+const exchange_1 = require("../exchange");
 const getMaxBoostUsd = (lltv, borrowLimit, debt, targetRatio = 1.01, bufferPercent = 1) => new decimal_js_1.default(targetRatio).mul(debt).sub(borrowLimit)
     .div(new decimal_js_1.default(lltv).sub(targetRatio).toString())
     .mul((100 - bufferPercent) / 100)
@@ -37,19 +38,19 @@ const getMorphoMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
     return maxLeverage;
 };
 exports.getMorphoMaxLeverageForSupplyAmount = getMorphoMaxLeverageForSupplyAmount;
-const getMorphoResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+const getMorphoResultingPosition = (marketData, supplyAmount, leverage, userAddress, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
     const provider = (0, viem_1.getViemProvider)(rpcUrl, network);
     const morphoMarket = positions_sdk_1.markets.MorphoBlueMarkets(network)[positions_sdk_1.MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915];
     const { rate: oracle, assetsData, } = marketData;
+    const supplyAsset = Object.values(assetsData).find((asset) => !asset.isDebtAsset);
+    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
     const debtAmount = new decimal_js_1.default(leverage)
         .times(supplyAmount).minus(supplyAmount).times(oracle)
         .toString();
-    // TODO: add price fetching logic
-    const priceForAmount = new decimal_js_1.default(1).div(oracle).toString();
-    const leveragedAmount = new decimal_js_1.default(debtAmount).times(priceForAmount);
+    const debtAmountWei = (0, tokens_1.assetAmountInWei)(debtAmount, borrowAsset.symbol);
+    const { priceWithFee, source } = yield (0, exchange_1.getBestPrice)(borrowAsset.symbol, supplyAsset.symbol, debtAmountWei, userAddress, network);
+    const leveragedAmount = new decimal_js_1.default(debtAmount).times(priceWithFee);
     const collIncrease = new decimal_js_1.default(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 positions_sdk_1.morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket);
     const usedAssets = {};
     usedAssets[borrowAsset.symbol] = {
@@ -73,6 +74,13 @@ const getMorphoResultingPosition = (marketData, supplyAmount, leverage, rpcUrl,
         borrowedUsd: '0',
     };
     const aggregatedPosition = positions_sdk_1.helpers.morphoBlueHelpers.getMorphoBlueAggregatedPositionData({ usedAssets, assetsData: morphoMarketData.assetsData, marketInfo: morphoMarketData });
-    return Object.assign({ usedAssets }, aggregatedPosition);
+    return Object.assign({ exchangeInfo: {
+            price: priceWithFee,
+            source,
+            sellAsset: borrowAsset.symbol,
+            sellAmount: debtAmount,
+            buyAsset: supplyAsset.symbol,
+            buyAmount: leveragedAmount.toString(),
+        }, usedAssets }, aggregatedPosition);
 });
 exports.getMorphoResultingPosition = getMorphoResultingPosition;

package/cjs/types/common.d.ts

@@ -1,5 +1,6 @@
 import { IncentiveData, MMUsedAssets, MorphoBlueAggregatedPositionData, NetworkNumber } from '@defisaver/positions-sdk';
 import { SupportedMarkets } from './markets';
+import { OffchainExchanges } from './exchange';
 export interface AssetData {
     symbol: string;
     address: string;
@@ -18,7 +19,16 @@ export interface MarketData {
     lltv: string;
     rate: string;
 }
+export interface ExchangeInfo {
+    price: string;
+    source: OffchainExchanges | 'None';
+    sellAsset: string;
+    sellAmount: string;
+    buyAsset: string;
+    buyAmount: string;
+}
 export interface PositionData extends MorphoBlueAggregatedPositionData {
     usedAssets: MMUsedAssets;
+    exchangeInfo: ExchangeInfo;
 }
 export { NetworkNumber, MMUsedAssets, IncentiveData, };

package/cjs/types/exchange.d.ts

@@ -0,0 +1,19 @@
+export declare enum OffchainExchanges {
+    ZeroX = "0x",
+    Paraswap = "Paraswap",
+    Kyberswap = "Kyberswap",
+    OneInch = "1Inch",
+    Bebop = "Bebop"
+}
+export interface PriceData {
+    price: string;
+    priceWithFee: string;
+    source: OffchainExchanges | 'None';
+    wrapper: string;
+    to: string;
+    allowanceTarget: string;
+    protocolFee: string;
+    data: string;
+    value: string;
+    gas: string;
+}

package/cjs/types/exchange.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffchainExchanges = void 0;
+var OffchainExchanges;
+(function (OffchainExchanges) {
+    OffchainExchanges["ZeroX"] = "0x";
+    OffchainExchanges["Paraswap"] = "Paraswap";
+    OffchainExchanges["Kyberswap"] = "Kyberswap";
+    OffchainExchanges["OneInch"] = "1Inch";
+    // Odos = 'Odos',
+    OffchainExchanges["Bebop"] = "Bebop";
+})(OffchainExchanges || (exports.OffchainExchanges = OffchainExchanges = {}));

package/cjs/types/index.d.ts

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

package/cjs/types/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./common"), exports);
 __exportStar(require("./markets"), exports);
+__exportStar(require("./exchange"), exports);

package/esm/constants/index.d.ts

@@ -0,0 +1,4 @@
+export declare const STABLE_PAIR_FEE_DIVIDER = "10000";
+export declare const DFS_API_URL = "https://fe.defisaver.com";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const SLIPPAGE_PERCENT = 0.05;

package/esm/constants/index.js

@@ -0,0 +1,4 @@
+export const STABLE_PAIR_FEE_DIVIDER = '10000';
+export const DFS_API_URL = 'https://fe.defisaver.com';
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const SLIPPAGE_PERCENT = 0.05;

package/esm/exchange/index.d.ts

@@ -0,0 +1,10 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { OffchainExchanges, PriceData } from '../types';
+export declare const numStringToBytes: (num: number) => string;
+export declare const getBestPrice: (fromAsset: string, toAsset: string, amount: string, userAddress: string, network?: NetworkNumber) => Promise<PriceData>;
+export declare const getExchangeOrder: (fromAsset: string, toAsset: string, amount: string, userAddress: string, minPrice: string, network?: NetworkNumber) => Promise<{
+    orderData: (string | string[])[];
+    value: string;
+    source: OffchainExchanges | "None";
+    price: string;
+}>;

package/esm/exchange/index.js

@@ -0,0 +1,176 @@
+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 BN from 'bn.js';
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { OffchainExchanges } from '../types';
+import { DFS_API_URL, SLIPPAGE_PERCENT, STABLE_PAIR_FEE_DIVIDER, ZERO_ADDRESS, } from '../constants';
+const getOffchainEmptyData = (source = 'None') => ({
+    wrapper: ZERO_ADDRESS,
+    to: ZERO_ADDRESS,
+    allowanceTarget: ZERO_ADDRESS,
+    price: '0',
+    priceWithFee: '0',
+    protocolFee: '0',
+    data: '0x00',
+    value: '0',
+    gas: '0',
+    source,
+});
+const parsePriceWithDecimals = (price, fromDecimals, toDecimals) => new Dec(price)
+    .div(Math.pow(10, toDecimals))
+    .div(Math.pow(10, (18 - fromDecimals)))
+    .toString();
+const formatPriceWithDecimalForContract = (price, fromDecimals, toDecimals) => new Dec(price)
+    .mul(Math.pow(10, toDecimals))
+    .mul(Math.pow(10, (18 - fromDecimals)))
+    .floor()
+    .toString();
+const includeFeeInPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new Dec(price).mul(new Dec(1).sub(fee)).toString();
+};
+const excludeFeeFromPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new Dec(price).mul(new Dec(1).add(fee)).toString();
+};
+const parseOffchainPrice = (fromTokenSymbol, fromTokenDecimals, toTokenSymbol, toTokenDecimals, amount, feeDecimal) => {
+    const _price = parsePriceWithDecimals(amount, fromTokenDecimals, toTokenDecimals);
+    return includeFeeInPrice(_price, fromTokenSymbol, toTokenSymbol, feeDecimal);
+};
+const getFeeDecimal = () => new Dec(1).div(STABLE_PAIR_FEE_DIVIDER).toString();
+export const numStringToBytes = (num) => {
+    const bn = new BN(num.toString()).toTwos(256);
+    return bn.toString(16);
+};
+const getPriceFromServer = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = NetworkNumber.Eth, infoOnly = true) {
+    const fromAssetData = getAssetInfo(fromAsset, network);
+    const toAssetData = getAssetInfo(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const excludedSources = ['Balancer_V2', 'Beethovenx'];
+    const allSources = Object.values(OffchainExchanges);
+    try {
+        const res = yield fetch(`${DFS_API_URL}/api/exchange/get-best-price`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                fromAsset: fromAssetData.address,
+                fromAssetDecimals: fromAssetData.decimals,
+                fromAssetSymbol: fromAssetData.symbol,
+                toAsset: toAssetData.address,
+                toAssetDecimals: toAssetData.decimals,
+                toAssetSymbol: toAssetData.symbol,
+                sources: [...allSources.map(s => s.toLowerCase())],
+                chainId: network,
+                amount,
+                excludedSources,
+                infoOnly,
+                takerAddress: userAddress,
+                account: userAddress,
+                noFee: false,
+                feeDecimal,
+                // temporary fix for paraswap until old exchange service is removed
+                shouldFormatParaswapPrice: true,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        const formattedData = data.map((d, i) => {
+            const source = allSources[i];
+            if (typeof d === 'string')
+                return getOffchainEmptyData(source);
+            return {
+                wrapper: d.wrapper || ZERO_ADDRESS,
+                to: d.to || ZERO_ADDRESS,
+                allowanceTarget: d.allowanceTarget || ZERO_ADDRESS,
+                protocolFee: d.protocolFee || '0',
+                data: d.data || '0x00',
+                value: d.value || '0',
+                gas: d.gas || '0',
+                source: allSources[i],
+                price: d.price,
+                priceWithFee: +(d.price || '0') > 0
+                    ? parseOffchainPrice(fromAssetData.symbol, fromAssetData.decimals, toAssetData.symbol, toAssetData.decimals, d.price, feeDecimal)
+                    : '0',
+            };
+        }).filter((d) => d.wrapper !== ZERO_ADDRESS && d.price !== '0').sort((a, b) => (new Dec(a.price).gt(b.price) ? -1 : 1));
+        return formattedData;
+    }
+    catch (_a) {
+        return allSources.map(source => getOffchainEmptyData(source));
+    }
+});
+export const getBestPrice = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = NetworkNumber.Eth) {
+    try {
+        const formattedData = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network);
+        return formattedData[0] || getOffchainEmptyData();
+    }
+    catch (e) {
+        console.error('Error fetching best price:', e);
+        return getOffchainEmptyData();
+    }
+});
+export const getExchangeOrder = (fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, minPrice, network = NetworkNumber.Eth) {
+    const fromAssetData = getAssetInfo(fromAsset, network);
+    const toAssetData = getAssetInfo(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const offchainQuotes = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network, false);
+    const formattedOffchainQuotes = offchainQuotes.map((quote) => ({
+        source: quote.source,
+        price: quote.priceWithFee,
+        wrapper: quote.wrapper,
+        wrapperData: quote.data,
+        offchainData: quote,
+    }));
+    const bestQuote = formattedOffchainQuotes[0];
+    const { offchainData, source, price } = bestQuote;
+    const minPriceFormatted = new Dec(excludeFeeFromPrice(minPrice, fromAssetData.address, toAssetData.address, feeDecimal))
+        .mul(100 - SLIPPAGE_PERCENT)
+        .div(100)
+        .toString();
+    const minPriceForContract = formatPriceWithDecimalForContract(minPriceFormatted, fromAssetData.decimals, toAssetData.decimals);
+    const offchainDataArray = [
+        offchainData.wrapper,
+        offchainData.to,
+        offchainData.allowanceTarget,
+        offchainData.price,
+        offchainData.protocolFee,
+        offchainData.data,
+    ];
+    const value = offchainData.protocolFee;
+    const wrapper = ZERO_ADDRESS;
+    const wrapperData = `0x${numStringToBytes(Math.floor(Date.now() / 1000))}`;
+    const amountWei = assetAmountInWei(amount, fromAsset).toString();
+    if (offchainData.data === '0x00')
+        throw new Error('Offchain data is empty');
+    return {
+        orderData: [
+            fromAssetData.address,
+            toAssetData.address,
+            amountWei,
+            '0',
+            minPriceForContract,
+            STABLE_PAIR_FEE_DIVIDER,
+            '0x0000000000000000000000000000000000000000', // set by contract
+            wrapper,
+            wrapperData,
+            offchainDataArray,
+        ],
+        value,
+        source,
+        price,
+    };
+});

package/esm/index.d.ts

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

package/esm/index.js

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

package/esm/positionData/index.d.ts

@@ -1,3 +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>;
+export declare const getResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/index.js

@@ -18,10 +18,10 @@ export const getMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
             throw new Error(`Unsupported market: ${marketData.market}`);
     }
 };
-export const getResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+export const getResultingPosition = (marketData, supplyAmount, leverage, userAddress, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
     switch (marketData.market) {
         case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
-            return getMorphoResultingPosition(marketData, supplyAmount, leverage, rpcUrl, network);
+            return getMorphoResultingPosition(marketData, supplyAmount, leverage, userAddress, rpcUrl, network);
         }
         default:
             throw new Error(`Unsupported market: ${marketData.market}`);

package/esm/positionData/morpho.d.ts

@@ -1,4 +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>;
+export declare const getMorphoResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/morpho.js

@@ -8,9 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import Dec from 'decimal.js';
-import { getAssetInfo } from '@defisaver/tokens';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
 import { helpers, markets, morphoBlue, MorphoBlueVersions, } from '@defisaver/positions-sdk';
 import { getViemProvider } from '../services/viem';
+import { getBestPrice } from '../exchange';
 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)
@@ -30,19 +31,19 @@ export const getMorphoMaxLeverageForSupplyAmount = (marketData, supplyAmount) =>
     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* () {
+export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, userAddress, 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 supplyAsset = Object.values(assetsData).find((asset) => !asset.isDebtAsset);
+    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
     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 debtAmountWei = assetAmountInWei(debtAmount, borrowAsset.symbol);
+    const { priceWithFee, source } = yield getBestPrice(borrowAsset.symbol, supplyAsset.symbol, debtAmountWei, userAddress, network);
+    const leveragedAmount = new Dec(debtAmount).times(priceWithFee);
     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] = {
@@ -66,5 +67,12 @@ export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, r
         borrowedUsd: '0',
     };
     const aggregatedPosition = helpers.morphoBlueHelpers.getMorphoBlueAggregatedPositionData({ usedAssets, assetsData: morphoMarketData.assetsData, marketInfo: morphoMarketData });
-    return Object.assign({ usedAssets }, aggregatedPosition);
+    return Object.assign({ exchangeInfo: {
+            price: priceWithFee,
+            source,
+            sellAsset: borrowAsset.symbol,
+            sellAmount: debtAmount,
+            buyAsset: supplyAsset.symbol,
+            buyAmount: leveragedAmount.toString(),
+        }, usedAssets }, aggregatedPosition);
 });

package/esm/types/common.d.ts

@@ -1,5 +1,6 @@
 import { IncentiveData, MMUsedAssets, MorphoBlueAggregatedPositionData, NetworkNumber } from '@defisaver/positions-sdk';
 import { SupportedMarkets } from './markets';
+import { OffchainExchanges } from './exchange';
 export interface AssetData {
     symbol: string;
     address: string;
@@ -18,7 +19,16 @@ export interface MarketData {
     lltv: string;
     rate: string;
 }
+export interface ExchangeInfo {
+    price: string;
+    source: OffchainExchanges | 'None';
+    sellAsset: string;
+    sellAmount: string;
+    buyAsset: string;
+    buyAmount: string;
+}
 export interface PositionData extends MorphoBlueAggregatedPositionData {
     usedAssets: MMUsedAssets;
+    exchangeInfo: ExchangeInfo;
 }
 export { NetworkNumber, MMUsedAssets, IncentiveData, };

package/esm/types/exchange.d.ts

@@ -0,0 +1,19 @@
+export declare enum OffchainExchanges {
+    ZeroX = "0x",
+    Paraswap = "Paraswap",
+    Kyberswap = "Kyberswap",
+    OneInch = "1Inch",
+    Bebop = "Bebop"
+}
+export interface PriceData {
+    price: string;
+    priceWithFee: string;
+    source: OffchainExchanges | 'None';
+    wrapper: string;
+    to: string;
+    allowanceTarget: string;
+    protocolFee: string;
+    data: string;
+    value: string;
+    gas: string;
+}

package/esm/types/exchange.js

@@ -0,0 +1,9 @@
+export var OffchainExchanges;
+(function (OffchainExchanges) {
+    OffchainExchanges["ZeroX"] = "0x";
+    OffchainExchanges["Paraswap"] = "Paraswap";
+    OffchainExchanges["Kyberswap"] = "Kyberswap";
+    OffchainExchanges["OneInch"] = "1Inch";
+    // Odos = 'Odos',
+    OffchainExchanges["Bebop"] = "Bebop";
+})(OffchainExchanges || (OffchainExchanges = {}));

package/esm/types/index.d.ts

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

package/esm/types/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/ethena-sdk",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "SDK for ethena lev create",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -27,6 +27,7 @@
   "dependencies": {
     "@defisaver/positions-sdk": "^2.1.57",
     "@defisaver/tokens": "^1.7.22",
+    "bn.js": "^5.1.3",
     "decimal.js": "^10.6.0",
     "viem": "^2.37.9"
   },

package/src/constants/index.ts

@@ -0,0 +1,4 @@
+export const STABLE_PAIR_FEE_DIVIDER = '10000';
+export const DFS_API_URL = 'https://fe.defisaver.com';
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const SLIPPAGE_PERCENT = 0.05;

package/src/exchange/index.ts

@@ -0,0 +1,195 @@
+import Dec from 'decimal.js';
+import BN from 'bn.js';
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { OffchainExchanges, PriceData } from '../types';
+import {
+  DFS_API_URL, SLIPPAGE_PERCENT, STABLE_PAIR_FEE_DIVIDER, ZERO_ADDRESS,
+} from '../constants';
+
+const getOffchainEmptyData = (source: OffchainExchanges | 'None' = 'None'): PriceData => ({
+  wrapper: ZERO_ADDRESS,
+  to: ZERO_ADDRESS,
+  allowanceTarget: ZERO_ADDRESS,
+  price: '0',
+  priceWithFee: '0',
+  protocolFee: '0',
+  data: '0x00',
+  value: '0',
+  gas: '0',
+  source,
+});
+
+const parsePriceWithDecimals = (price: string, fromDecimals: number, toDecimals: number) => new Dec(price)
+  .div(10 ** toDecimals)
+  .div(10 ** (18 - fromDecimals))
+  .toString();
+
+const formatPriceWithDecimalForContract = (price: string, fromDecimals: number, toDecimals: number) => new Dec(price)
+  .mul(10 ** toDecimals)
+  .mul(10 ** (18 - fromDecimals))
+  .floor()
+  .toString();
+
+const includeFeeInPrice = (price: string, from: string, to: string, fee: string) => {
+  if (from === to) return price;
+  return new Dec(price).mul(new Dec(1).sub(fee)).toString();
+};
+
+const excludeFeeFromPrice = (price: string, from: string, to: string, fee: string) => {
+  if (from === to) return price;
+  return new Dec(price).mul(new Dec(1).add(fee)).toString();
+};
+
+const parseOffchainPrice = (
+  fromTokenSymbol: string,
+  fromTokenDecimals: number,
+  toTokenSymbol: string,
+  toTokenDecimals: number,
+  amount: string,
+  feeDecimal: string,
+): string => {
+  const _price = parsePriceWithDecimals(amount, fromTokenDecimals, toTokenDecimals);
+  return includeFeeInPrice(_price, fromTokenSymbol, toTokenSymbol, feeDecimal);
+};
+
+const getFeeDecimal = () => new Dec(1).div(STABLE_PAIR_FEE_DIVIDER).toString();
+
+export const numStringToBytes = (num: number) => {
+  const bn = new BN(num.toString()).toTwos(256);
+  return bn.toString(16);
+};
+
+const getPriceFromServer = async (fromAsset: string, toAsset: string, amount: string, userAddress: string, network: NetworkNumber = NetworkNumber.Eth, infoOnly: boolean = true) => {
+  const fromAssetData = getAssetInfo(fromAsset, network);
+  const toAssetData = getAssetInfo(toAsset, network);
+  const feeDecimal = getFeeDecimal();
+  const excludedSources = ['Balancer_V2', 'Beethovenx'];
+
+  const allSources = Object.values(OffchainExchanges);
+
+  try {
+    const res = await fetch(`${DFS_API_URL}/api/exchange/get-best-price`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        fromAsset: fromAssetData.address,
+        fromAssetDecimals: fromAssetData.decimals,
+        fromAssetSymbol: fromAssetData.symbol,
+        toAsset: toAssetData.address,
+        toAssetDecimals: toAssetData.decimals,
+        toAssetSymbol: toAssetData.symbol,
+        sources: [...allSources.map(s => s.toLowerCase())],
+        chainId: network,
+        amount,
+        excludedSources,
+        infoOnly,
+        takerAddress: userAddress,
+        account: userAddress,
+        noFee: false,
+        feeDecimal,
+        // temporary fix for paraswap until old exchange service is removed
+        shouldFormatParaswapPrice: true,
+      }),
+    });
+
+    if (!res.ok) throw new Error(await res.text());
+    const data = (await res.json());
+
+    const formattedData: PriceData[] = data.map((d: any, i: number) => {
+      const source = allSources[i];
+      if (typeof d === 'string') return getOffchainEmptyData(source);
+      return {
+        wrapper: d.wrapper || ZERO_ADDRESS,
+        to: d.to || ZERO_ADDRESS,
+        allowanceTarget: d.allowanceTarget || ZERO_ADDRESS,
+        protocolFee: d.protocolFee || '0',
+        data: d.data || '0x00',
+        value: d.value || '0',
+        gas: d.gas || '0',
+        source: allSources[i],
+        price: d.price,
+        priceWithFee: +(d.price || '0') > 0
+          ? parseOffchainPrice(fromAssetData.symbol, fromAssetData.decimals, toAssetData.symbol, toAssetData.decimals, d.price, feeDecimal)
+          : '0',
+      };
+    }).filter((d: PriceData) => d.wrapper !== ZERO_ADDRESS && d.price !== '0').sort((a: PriceData, b: PriceData) => (new Dec(a.price).gt(b.price) ? -1 : 1));
+
+    return formattedData;
+  } catch {
+    return allSources.map(source => getOffchainEmptyData(source));
+  }
+};
+
+export const getBestPrice = async (fromAsset: string, toAsset: string, amount: string, userAddress: string, network: NetworkNumber = NetworkNumber.Eth): Promise<PriceData> => {
+  try {
+    const formattedData: PriceData[] = await getPriceFromServer(fromAsset, toAsset, amount, userAddress, network);
+
+    return formattedData[0] || getOffchainEmptyData();
+  } catch (e) {
+    console.error('Error fetching best price:', e);
+    return getOffchainEmptyData();
+  }
+};
+
+export const getExchangeOrder = async (fromAsset: string, toAsset: string, amount: string, userAddress: string, minPrice: string, network: NetworkNumber = NetworkNumber.Eth) => {
+  const fromAssetData = getAssetInfo(fromAsset, network);
+  const toAssetData = getAssetInfo(toAsset, network);
+  const feeDecimal = getFeeDecimal();
+
+  const offchainQuotes: PriceData[] = await getPriceFromServer(fromAsset, toAsset, amount, userAddress, network, false);
+
+  const formattedOffchainQuotes = offchainQuotes.map((quote) => ({
+    source: quote.source,
+    price: quote.priceWithFee,
+    wrapper: quote.wrapper,
+    wrapperData: quote.data,
+    offchainData: quote,
+  }));
+
+  const bestQuote = formattedOffchainQuotes[0];
+  const { offchainData, source, price } = bestQuote;
+
+  const minPriceFormatted = new Dec(excludeFeeFromPrice(minPrice, fromAssetData.address, toAssetData.address, feeDecimal))
+    .mul(100 - SLIPPAGE_PERCENT)
+    .div(100)
+    .toString();
+  const minPriceForContract = formatPriceWithDecimalForContract(minPriceFormatted, fromAssetData.decimals, toAssetData.decimals);
+
+  const offchainDataArray = [
+    offchainData.wrapper,
+    offchainData.to,
+    offchainData.allowanceTarget,
+    offchainData.price,
+    offchainData.protocolFee,
+    offchainData.data,
+  ];
+
+  const value = offchainData.protocolFee;
+
+  const wrapper = ZERO_ADDRESS;
+  const wrapperData = `0x${numStringToBytes(Math.floor(Date.now() / 1000))}`;
+  const amountWei = assetAmountInWei(amount, fromAsset).toString();
+
+  if (offchainData.data === '0x00') throw new Error('Offchain data is empty');
+
+  return {
+    orderData: [
+      fromAssetData.address,
+      toAssetData.address,
+      amountWei,
+      '0',
+      minPriceForContract,
+      STABLE_PAIR_FEE_DIVIDER,
+      '0x0000000000000000000000000000000000000000', // set by contract
+      wrapper,
+      wrapperData,
+      offchainDataArray,
+    ],
+    value,
+    source,
+    price,
+  };
+};

package/src/index.ts

@@ -2,10 +2,14 @@ import './setup';
 
 import * as positionData from './positionData';
 import * as marketData from './marketData';
+import * as exchange from './exchange';
+import * as constants from './constants';
 
 export * from './types';
 
 export {
   positionData,
   marketData,
+  exchange,
+  constants,
 };

package/src/positionData/index.ts

@@ -13,10 +13,10 @@ export const getMaxLeverageForSupplyAmount = (marketData: MarketData, supplyAmou
   }
 };
 
-export const getResultingPosition = async (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber): Promise<PositionData> => {
+export const getResultingPosition = async (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber): Promise<PositionData> => {
   switch (marketData.market) {
     case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
-      return getMorphoResultingPosition(marketData, supplyAmount, leverage, rpcUrl, network);
+      return getMorphoResultingPosition(marketData, supplyAmount, leverage, userAddress, rpcUrl, network);
     }
     default:
       throw new Error(`Unsupported market: ${marketData.market}`);

package/src/positionData/morpho.ts

@@ -1,10 +1,11 @@
 import Dec from 'decimal.js';
-import { getAssetInfo } from '@defisaver/tokens';
+import { assetAmountInWei, 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';
+import { getBestPrice } from '../exchange';
 
 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())
@@ -38,24 +39,24 @@ export const getMorphoMaxLeverageForSupplyAmount = (marketData: MarketData, supp
   return maxLeverage;
 };
 
-export const getMorphoResultingPosition = async (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber): Promise<PositionData> => {
+export const getMorphoResultingPosition = async (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, 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 supplyAsset: AssetData = Object.values(assetsData).find((asset) => !asset.isDebtAsset)!;
+  const borrowAsset: AssetData = Object.values(assetsData).find((asset) => asset.isDebtAsset)!;
   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 debtAmountWei = assetAmountInWei(debtAmount, borrowAsset.symbol);
+  const { priceWithFee, source } = await getBestPrice(borrowAsset.symbol, supplyAsset.symbol, debtAmountWei, userAddress, network);
 
-  const supplyAsset: AssetData = Object.values(assetsData).find((asset) => !asset.isDebtAsset)!;
-  const borrowAsset: AssetData = Object.values(assetsData).find((asset) => asset.isDebtAsset)!;
+  const leveragedAmount = new Dec(debtAmount).times(priceWithFee);
+  const collIncrease = new Dec(supplyAmount).plus(leveragedAmount).toString();
 
   const morphoMarketData = await morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket);
   const usedAssets: MMUsedAssets = {};
@@ -84,6 +85,14 @@ export const getMorphoResultingPosition = async (marketData: MarketData, supplyA
 
   const aggregatedPosition = helpers.morphoBlueHelpers.getMorphoBlueAggregatedPositionData({ usedAssets, assetsData: morphoMarketData.assetsData, marketInfo: morphoMarketData });
   return {
+    exchangeInfo: {
+      price: priceWithFee,
+      source,
+      sellAsset: borrowAsset.symbol,
+      sellAmount: debtAmount,
+      buyAsset: supplyAsset.symbol,
+      buyAmount: leveragedAmount.toString(),
+    },
     usedAssets,
     ...aggregatedPosition,
   };

package/src/types/common.ts

@@ -2,6 +2,7 @@ import {
   IncentiveData, MMUsedAssets, MorphoBlueAggregatedPositionData, NetworkNumber,
 } from '@defisaver/positions-sdk';
 import { SupportedMarkets } from './markets';
+import { OffchainExchanges } from './exchange';
 
 export interface AssetData {
   symbol: string;
@@ -23,8 +24,18 @@ export interface MarketData {
   rate: string;
 }
 
+export interface ExchangeInfo {
+  price: string;
+  source: OffchainExchanges | 'None';
+  sellAsset: string;
+  sellAmount: string;
+  buyAsset: string;
+  buyAmount: string;
+}
+
 export interface PositionData extends MorphoBlueAggregatedPositionData {
   usedAssets: MMUsedAssets;
+  exchangeInfo: ExchangeInfo;
 }
 
 export {

package/src/types/exchange.ts

@@ -0,0 +1,21 @@
+export enum OffchainExchanges {
+  ZeroX = '0x',
+  Paraswap = 'Paraswap',
+  Kyberswap = 'Kyberswap',
+  OneInch = '1Inch',
+  // Odos = 'Odos',
+  Bebop = 'Bebop',
+}
+
+export interface PriceData {
+  price: string;
+  priceWithFee: string;
+  source: OffchainExchanges | 'None';
+  wrapper: string;
+  to: string;
+  allowanceTarget: string;
+  protocolFee: string;
+  data: string;
+  value: string;
+  gas: string;
+}

package/src/types/index.ts

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