@defisaver/ethena-sdk 0.0.4 → 0.0.6

package/src/execution/morpho.ts

@@ -0,0 +1,47 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { MorphoManagerContract } from '../contracts';
+import { getViemProvider } from '../services/viem';
+import { Request, RequestType } from '../types';
+import { predictSafeAddress } from '../safe';
+
+const morphoAuthSignature: Request = {
+  type: RequestType.Signature,
+  getParams: async (rpcUrl: string, network: NetworkNumber, userAddress: string) => {
+    const provider = getViemProvider(rpcUrl, network);
+    const managerContract = MorphoManagerContract(provider, network);
+    const nonce = await managerContract.read.nonce([userAddress as `0x${string}`]);
+    const tenMinutes = 1000 * 60 * 10;
+    const deadline = Date.now() + tenMinutes;
+    const safeAddress = await 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,
+      },
+    };
+  },
+};
+
+export const getMorphoRequests = () => [morphoAuthSignature];

package/src/index.ts

@@ -2,10 +2,18 @@ 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,
+  exchange,
+  constants,
+  safe,
+  execution,
 };

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

@@ -0,0 +1,99 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import {
+  encodeFunctionData, encodePacked, getCreate2Address, keccak256,
+} from 'viem';
+import { Wallet } from '../types';
+import {
+  SAFE_API_URL, SAFE_REFUND_RECEIVER, SALT_PREFIX, ZERO_ADDRESS,
+} from '../constants';
+import {
+  getConfigContractAbi,
+  getSafeFactoryAddress, getSafeFallbackHandlerAddress, getSafeWalletSingletonAddress, SafeFactoryContract,
+} from '../contracts';
+import { getViemProvider } from '../services/viem';
+
+export const getSafeWallets = async (userAddress: string, network: NetworkNumber): Promise<{ success: boolean, wallets: string[] }> => {
+  try {
+    const res = await fetch(`${SAFE_API_URL}/safe/all-wallets?network=${network}&account=${userAddress}`);
+    const wallets = await res.json();
+
+    const oneOneWallets = wallets
+      .filter((wallet: Wallet) => wallet.type === 'Safe' && (wallet.owners || []).length === 1)
+      .map((wallet: Wallet) => wallet.address);
+    return { success: true, wallets: oneOneWallets };
+  } catch (e) {
+    return { success: false, wallets: [] };
+  }
+};
+
+const getSafeSetupParams = (owners: string[], threshold: number, network: NetworkNumber) => [
+  owners as `0x${string}`[],
+  BigInt(threshold),
+  ZERO_ADDRESS as `0x${string}`,
+  '0x',
+  getSafeFallbackHandlerAddress(network) as `0x${string}`,
+  ZERO_ADDRESS as `0x${string}`,
+  BigInt(0),
+  SAFE_REFUND_RECEIVER as `0x${string}`,
+];
+
+const _predictSafeAddress = async (
+  rpcUrl: string,
+  network: NetworkNumber,
+  setupArgs: string,
+  saltNonce: string,
+) => {
+  const provider = getViemProvider(rpcUrl, network);
+  const safeProxyFactoryAddress = getSafeFactoryAddress(network);
+  const safeProxyFactoryContract = SafeFactoryContract(provider, network);
+  const masterCopyAddress = getSafeWalletSingletonAddress(network);
+
+  const proxyCreationCode = await safeProxyFactoryContract.read.proxyCreationCode();
+
+  // @ts-ignore
+  const initCodeHash = keccak256(
+    encodePacked(['bytes', 'bytes'], [proxyCreationCode, masterCopyAddress.slice(2).padStart(64, '0') as `0x${string}`]), 'bytes',
+  ) as string;
+
+  const salt = keccak256(
+    encodePacked(
+      ['bytes', 'uint256'],
+      [keccak256(setupArgs as `0x${string}`), BigInt(saltNonce)],
+    ),
+  );
+
+  return getCreate2Address(
+    {
+      bytecodeHash: initCodeHash as `0x${string}`,
+      from: safeProxyFactoryAddress,
+      salt,
+    },
+  );
+};
+
+export const predictSafeAddress = async (owner: string, rpcUrl: string, network: NetworkNumber): Promise<string> => {
+  const provider = getViemProvider(rpcUrl, network);
+
+  const threshold = 1;
+  const owners = [owner];
+  const setupParams = getSafeSetupParams(owners, threshold, network);
+  const setupParamsEncoded = encodeFunctionData({
+    abi: getConfigContractAbi('Safe130'),
+    functionName: 'setup',
+    // @ts-ignore
+    args: setupParams,
+  });
+  const oneOfOneWalletsCount = (await getSafeWallets(owner, network)).wallets.length;
+  const failAfter = 10;
+  for (let nonce = oneOfOneWalletsCount + 1; nonce < oneOfOneWalletsCount + failAfter + 1; nonce += 1) {
+    const salt = `${SALT_PREFIX}${nonce}`;
+    const predictedAddr = await _predictSafeAddress(rpcUrl, network, setupParamsEncoded, salt);
+    const bytecode = await provider.getCode({ address: predictedAddr });
+    if (!bytecode) {
+      // safe does not exist
+      return predictedAddr;
+    }
+  }
+
+  return '';
+};

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

@@ -0,0 +1,11 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+
+export enum RequestType {
+  Signature = 'Signature',
+  EthCall = 'EthCall',
+}
+
+export interface Request {
+  type: RequestType;
+  getParams: (rpcUrl: string, network: NetworkNumber, userAddress: string) => Promise<any>;
+}

package/src/types/index.ts

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

package/src/types/safe.ts

@@ -0,0 +1,5 @@
+export type Wallet = {
+  address: string;
+  type: string;
+  owners?: string[];
+};