@defisaver/ethena-sdk 0.0.4 → 0.0.6

package/cjs/contracts.js

@@ -0,0 +1,80 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSafeFallbackHandlerAddress = exports.getSafeFactoryAddress = exports.getSafeWalletSingletonAddress = exports.getSafeWalletContract = exports.MorphoManagerContract = exports.SafeFactoryContract = exports.Safe130Contract = exports.createContractFromConfigFunc = exports.getConfigContractAbi = exports.getConfigContractAddress = void 0;
+const viem_1 = require("viem");
+const positions_sdk_1 = require("@defisaver/positions-sdk");
+const configRaw = __importStar(require("./config/contracts"));
+// @ts-ignore
+const contractConfig = configRaw;
+const getConfigContractAddress = (name, network) => {
+    const networkData = contractConfig[name].networks[network];
+    const latestAddress = (networkData === null || networkData === void 0 ? void 0 : networkData.address) || '';
+    return latestAddress;
+};
+exports.getConfigContractAddress = getConfigContractAddress;
+const getConfigContractAbi = (name) => {
+    const latestAbi = contractConfig[name].abi;
+    return latestAbi;
+};
+exports.getConfigContractAbi = getConfigContractAbi;
+const createContractFromConfigFunc = (name, _address) => (client, network) => {
+    const address = (_address || (0, exports.getConfigContractAddress)(name, network));
+    const abi = (0, exports.getConfigContractAbi)(name);
+    return (0, viem_1.getContract)({
+        address,
+        abi,
+        client,
+    });
+};
+exports.createContractFromConfigFunc = createContractFromConfigFunc;
+exports.Safe130Contract = (0, exports.createContractFromConfigFunc)('Safe130');
+exports.SafeFactoryContract = (0, exports.createContractFromConfigFunc)('SafeProxyFactory130');
+exports.MorphoManagerContract = (0, exports.createContractFromConfigFunc)('MorphoManager');
+const getSafeWalletContract = (client, address) => {
+    const abi = (0, exports.getConfigContractAbi)('Safe130');
+    return (0, viem_1.getContract)({
+        address,
+        abi,
+        client,
+    });
+};
+exports.getSafeWalletContract = getSafeWalletContract;
+const getSafeWalletSingletonAddress = (network) => (0, exports.getConfigContractAddress)('Safe130', network || positions_sdk_1.NetworkNumber.Eth);
+exports.getSafeWalletSingletonAddress = getSafeWalletSingletonAddress;
+const getSafeFactoryAddress = (network) => (0, exports.getConfigContractAddress)('SafeProxyFactory130', network || positions_sdk_1.NetworkNumber.Eth);
+exports.getSafeFactoryAddress = getSafeFactoryAddress;
+const getSafeFallbackHandlerAddress = (network) => (0, exports.getConfigContractAddress)('SafeFallbackHandler130', network || positions_sdk_1.NetworkNumber.Eth);
+exports.getSafeFallbackHandlerAddress = getSafeFallbackHandlerAddress;

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/execution/index.d.ts

@@ -0,0 +1,2 @@
+import { SupportedMarkets } from '../types';
+export declare const getRequests: (market: SupportedMarkets) => import("../types").Request[];

package/cjs/execution/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequests = void 0;
+const types_1 = require("../types");
+const morpho_1 = require("./morpho");
+const getRequests = (market) => {
+    switch (market) {
+        case types_1.SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return (0, morpho_1.getMorphoRequests)();
+        }
+        default:
+            throw new Error(`Unsupported market: ${market}`);
+    }
+};
+exports.getRequests = getRequests;

package/cjs/execution/morpho.d.ts

@@ -0,0 +1,2 @@
+import { Request } from '../types';
+export declare const getMorphoRequests: () => Request[];

package/cjs/execution/morpho.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMorphoRequests = void 0;
+const contracts_1 = require("../contracts");
+const viem_1 = require("../services/viem");
+const types_1 = require("../types");
+const safe_1 = require("../safe");
+const morphoAuthSignature = {
+    type: types_1.RequestType.Signature,
+    getParams: (rpcUrl, network, userAddress) => __awaiter(void 0, void 0, void 0, function* () {
+        const provider = (0, viem_1.getViemProvider)(rpcUrl, network);
+        const managerContract = (0, contracts_1.MorphoManagerContract)(provider, network);
+        const nonce = yield managerContract.read.nonce([userAddress]);
+        const tenMinutes = 1000 * 60 * 10;
+        const deadline = Date.now() + tenMinutes;
+        const safeAddress = yield (0, safe_1.predictSafeAddress)(userAddress, rpcUrl, network);
+        return {
+            types: {
+                EIP712Domain: [
+                    { name: 'verifyingContract', type: 'address' },
+                    { name: 'chainId', type: 'uint256' },
+                ],
+                Authorization: [
+                    { name: 'authorizer', type: 'address' },
+                    { name: 'authorized', type: 'address' },
+                    { name: 'isAuthorized', type: 'bool' },
+                    { name: 'nonce', type: 'uint256' },
+                    { name: 'deadline', type: 'uint256' },
+                ],
+            },
+            domain: {
+                chainId: network,
+                verifyingContract: managerContract.address,
+            },
+            primaryType: 'Authorization',
+            message: {
+                authorizer: userAddress,
+                authorized: safeAddress,
+                isAuthorized: true,
+                nonce: +nonce.toString(),
+                deadline,
+            },
+        };
+    }),
+};
+const getMorphoRequests = () => [morphoAuthSignature];
+exports.getMorphoRequests = getMorphoRequests;

package/cjs/index.d.ts

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

package/cjs/index.js

@@ -36,10 +36,18 @@ 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.execution = exports.safe = 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;
+const safe = __importStar(require("./safe"));
+exports.safe = safe;
+const execution = __importStar(require("./execution"));
+exports.execution = execution;
 __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/safe/index.d.ts

@@ -0,0 +1,6 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+export declare const getSafeWallets: (userAddress: string, network: NetworkNumber) => Promise<{
+    success: boolean;
+    wallets: string[];
+}>;
+export declare const predictSafeAddress: (owner: string, rpcUrl: string, network: NetworkNumber) => Promise<string>;

package/cjs/safe/index.js

@@ -0,0 +1,80 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.predictSafeAddress = exports.getSafeWallets = void 0;
+const viem_1 = require("viem");
+const constants_1 = require("../constants");
+const contracts_1 = require("../contracts");
+const viem_2 = require("../services/viem");
+const getSafeWallets = (userAddress, network) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield fetch(`${constants_1.SAFE_API_URL}/safe/all-wallets?network=${network}&account=${userAddress}`);
+        const wallets = yield res.json();
+        const oneOneWallets = wallets
+            .filter((wallet) => wallet.type === 'Safe' && (wallet.owners || []).length === 1)
+            .map((wallet) => wallet.address);
+        return { success: true, wallets: oneOneWallets };
+    }
+    catch (e) {
+        return { success: false, wallets: [] };
+    }
+});
+exports.getSafeWallets = getSafeWallets;
+const getSafeSetupParams = (owners, threshold, network) => [
+    owners,
+    BigInt(threshold),
+    constants_1.ZERO_ADDRESS,
+    '0x',
+    (0, contracts_1.getSafeFallbackHandlerAddress)(network),
+    constants_1.ZERO_ADDRESS,
+    BigInt(0),
+    constants_1.SAFE_REFUND_RECEIVER,
+];
+const _predictSafeAddress = (rpcUrl, network, setupArgs, saltNonce) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = (0, viem_2.getViemProvider)(rpcUrl, network);
+    const safeProxyFactoryAddress = (0, contracts_1.getSafeFactoryAddress)(network);
+    const safeProxyFactoryContract = (0, contracts_1.SafeFactoryContract)(provider, network);
+    const masterCopyAddress = (0, contracts_1.getSafeWalletSingletonAddress)(network);
+    const proxyCreationCode = yield safeProxyFactoryContract.read.proxyCreationCode();
+    // @ts-ignore
+    const initCodeHash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes', 'bytes'], [proxyCreationCode, masterCopyAddress.slice(2).padStart(64, '0')]), 'bytes');
+    const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes', 'uint256'], [(0, viem_1.keccak256)(setupArgs), BigInt(saltNonce)]));
+    return (0, viem_1.getCreate2Address)({
+        bytecodeHash: initCodeHash,
+        from: safeProxyFactoryAddress,
+        salt,
+    });
+});
+const predictSafeAddress = (owner, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = (0, viem_2.getViemProvider)(rpcUrl, network);
+    const threshold = 1;
+    const owners = [owner];
+    const setupParams = getSafeSetupParams(owners, threshold, network);
+    const setupParamsEncoded = (0, viem_1.encodeFunctionData)({
+        abi: (0, contracts_1.getConfigContractAbi)('Safe130'),
+        functionName: 'setup',
+        // @ts-ignore
+        args: setupParams,
+    });
+    const oneOfOneWalletsCount = (yield (0, exports.getSafeWallets)(owner, network)).wallets.length;
+    const failAfter = 10;
+    for (let nonce = oneOfOneWalletsCount + 1; nonce < oneOfOneWalletsCount + failAfter + 1; nonce += 1) {
+        const salt = `${constants_1.SALT_PREFIX}${nonce}`;
+        const predictedAddr = yield _predictSafeAddress(rpcUrl, network, setupParamsEncoded, salt);
+        const bytecode = yield provider.getCode({ address: predictedAddr });
+        if (!bytecode) {
+            // safe does not exist
+            return predictedAddr;
+        }
+    }
+    return '';
+});
+exports.predictSafeAddress = predictSafeAddress;