@defisaver/automation-sdk 3.3.6 → 3.3.7-morpho-dev

package/esm/services/utils.test.js

@@ -1,11 +1,8 @@
 import { expect } from 'chai';
-import * as web3Utils from 'web3-utils';
-import AbiCoder from 'web3-eth-abi';
 import { getAssetInfo } from '@defisaver/tokens';
 import { ChainId, ProtocolIdentifiers, RatioState } from '../types/enums';
-import { sparkEncode } from './strategySubService';
 import '../configuration';
-import { addToArrayIf, addToObjectIf, compareAddresses, compareSubHashes, encodeSubId, ethToWeth, getRatioStateInfoForAaveCloseStrategy, isAddress, isDefined, isEmptyBytes, isRatioStateOver, isRatioStateUnder, isUndefined, ratioPercentageToWei, requireAddress, requireAddresses, weiToRatioPercentage, wethToEth, wethToEthByAddress, getPositionId, } from './utils';
+import { addToArrayIf, addToObjectIf, compareAddresses, encodeSubId, ethToWeth, getRatioStateInfoForAaveCloseStrategy, isAddress, isDefined, isEmptyBytes, isRatioStateOver, isRatioStateUnder, isUndefined, ratioPercentageToWei, requireAddress, requireAddresses, weiToRatioPercentage, wethToEth, wethToEthByAddress, getPositionId, } from './utils';
 describe('Feature: utils.ts', () => {
     describe('When testing utils.isDefined()', () => {
         const examples = [
@@ -139,54 +136,6 @@ describe('Feature: utils.ts', () => {
             });
         });
     });
-    describe('When testing utils.compareSubHashes()', () => {
-        const subDataToEncodeOne = [
-            12,
-            false,
-            {
-                baseTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                quoteTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                price: 100,
-                ratioState: 1,
-            },
-            {
-                collAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                collAssetId: 2,
-                debtAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                debtAssetId: 3,
-            },
-        ];
-        const subDataToEncodeTwo = [
-            13,
-            true,
-            {
-                baseTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                quoteTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                price: 100,
-                ratioState: 2,
-            },
-            {
-                collAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                collAssetId: 2,
-                debtAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-                debtAssetId: 3,
-            },
-        ];
-        // @ts-ignore
-        const encodedSubDataOne = sparkEncode.closeToAsset(...subDataToEncodeOne);
-        // @ts-ignore
-        const encodedSubDataTwo = sparkEncode.closeToAsset(...subDataToEncodeTwo);
-        const encodedParams = web3Utils.keccak256(AbiCoder.encodeParameter('(uint64,bool,bytes[],bytes32[])', encodedSubDataOne));
-        const examples = [
-            [true, [encodedParams, encodedSubDataOne]],
-            [false, [encodedParams, encodedSubDataTwo]],
-        ];
-        examples.forEach(([expected, actual]) => {
-            it(`Given ${actual} should return expected value: ${expected}`, () => {
-                expect(compareSubHashes(...actual)).to.equal(expected);
-            });
-        });
-    });
     describe('When testing utils.encodeSubId()', () => {
         const examples = [
             ['00000001', '1'],

package/esm/types/enums.d.ts

@@ -171,8 +171,6 @@ export declare namespace Bundles {
         LIQUITY_BOOST = 17,
         SPARK_REPAY = 18,
         SPARK_BOOST = 19,
-        SPARK_CLOSE_TO_DEBT = -21231230,
-        SPARK_CLOSE_TO_COLLATERAL = -21231231,
         AAVE_V2_REPAY = 22,
         AAVE_V2_BOOST = 23,
         COMP_V2_REPAY = 20,
@@ -207,7 +205,9 @@ export declare namespace Bundles {
         AAVE_V3_EOA_BOOST = 53,
         AAVE_V3_EOA_REPAY_ON_PRICE = 54,
         AAVE_V3_EOA_BOOST_ON_PRICE = 55,
-        AAVE_V3_EOA_CLOSE = 56
+        AAVE_V3_EOA_CLOSE = 56,
+        SPARK_CLOSE = 57,
+        MORPHO_BLUE_CLOSE = 58
     }
     enum OptimismIds {
         AAVE_V3_REPAY = 0,
@@ -248,7 +248,8 @@ export declare namespace Bundles {
         AAVE_V3_EOA_BOOST = 24,
         AAVE_V3_EOA_REPAY_ON_PRICE = 25,
         AAVE_V3_EOA_BOOST_ON_PRICE = 26,
-        AAVE_V3_EOA_CLOSE = 27
+        AAVE_V3_EOA_CLOSE = 27,
+        MORPHO_BLUE_CLOSE = 28
     }
     enum ArbitrumIds {
         AAVE_V3_REPAY = 0,
@@ -278,6 +279,7 @@ export declare namespace Bundles {
         MORPHO_BLUE_BOOST = 24,
         MORPHO_BLUE_BOOST_ON_PRICE = 25,
         MORPHO_BLUE_EOA_REPAY = 26,
-        MORPHO_BLUE_EOA_BOOST = 27
+        MORPHO_BLUE_EOA_BOOST = 27,
+        MORPHO_BLUE_CLOSE = 28
     }
 }

package/esm/types/enums.js

@@ -191,8 +191,6 @@ export var Bundles;
         MainnetIds[MainnetIds["LIQUITY_BOOST"] = 17] = "LIQUITY_BOOST";
         MainnetIds[MainnetIds["SPARK_REPAY"] = 18] = "SPARK_REPAY";
         MainnetIds[MainnetIds["SPARK_BOOST"] = 19] = "SPARK_BOOST";
-        MainnetIds[MainnetIds["SPARK_CLOSE_TO_DEBT"] = -21231230] = "SPARK_CLOSE_TO_DEBT";
-        MainnetIds[MainnetIds["SPARK_CLOSE_TO_COLLATERAL"] = -21231231] = "SPARK_CLOSE_TO_COLLATERAL";
         MainnetIds[MainnetIds["AAVE_V2_REPAY"] = 22] = "AAVE_V2_REPAY";
         MainnetIds[MainnetIds["AAVE_V2_BOOST"] = 23] = "AAVE_V2_BOOST";
         MainnetIds[MainnetIds["COMP_V2_REPAY"] = 20] = "COMP_V2_REPAY";
@@ -228,6 +226,8 @@ export var Bundles;
         MainnetIds[MainnetIds["AAVE_V3_EOA_REPAY_ON_PRICE"] = 54] = "AAVE_V3_EOA_REPAY_ON_PRICE";
         MainnetIds[MainnetIds["AAVE_V3_EOA_BOOST_ON_PRICE"] = 55] = "AAVE_V3_EOA_BOOST_ON_PRICE";
         MainnetIds[MainnetIds["AAVE_V3_EOA_CLOSE"] = 56] = "AAVE_V3_EOA_CLOSE";
+        MainnetIds[MainnetIds["SPARK_CLOSE"] = 57] = "SPARK_CLOSE";
+        MainnetIds[MainnetIds["MORPHO_BLUE_CLOSE"] = 58] = "MORPHO_BLUE_CLOSE";
     })(MainnetIds = Bundles.MainnetIds || (Bundles.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {
@@ -271,6 +271,7 @@ export var Bundles;
         BaseIds[BaseIds["AAVE_V3_EOA_REPAY_ON_PRICE"] = 25] = "AAVE_V3_EOA_REPAY_ON_PRICE";
         BaseIds[BaseIds["AAVE_V3_EOA_BOOST_ON_PRICE"] = 26] = "AAVE_V3_EOA_BOOST_ON_PRICE";
         BaseIds[BaseIds["AAVE_V3_EOA_CLOSE"] = 27] = "AAVE_V3_EOA_CLOSE";
+        BaseIds[BaseIds["MORPHO_BLUE_CLOSE"] = 28] = "MORPHO_BLUE_CLOSE";
     })(BaseIds = Bundles.BaseIds || (Bundles.BaseIds = {}));
     let ArbitrumIds;
     (function (ArbitrumIds) {
@@ -302,5 +303,6 @@ export var Bundles;
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_BOOST_ON_PRICE"] = 25] = "MORPHO_BLUE_BOOST_ON_PRICE";
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_EOA_REPAY"] = 26] = "MORPHO_BLUE_EOA_REPAY";
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_EOA_BOOST"] = 27] = "MORPHO_BLUE_EOA_BOOST";
+        ArbitrumIds[ArbitrumIds["MORPHO_BLUE_CLOSE"] = 28] = "MORPHO_BLUE_CLOSE";
     })(ArbitrumIds = Bundles.ArbitrumIds || (Bundles.ArbitrumIds = {}));
 })(Bundles || (Bundles = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.6",
+  "version": "3.3.7-morpho-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/constants/index.ts

@@ -331,16 +331,6 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.Boost,
     protocol: PROTOCOLS.Spark,
   },
-  [Bundles.MainnetIds.SPARK_CLOSE_TO_DEBT]: {
-    strategyOrBundleId: Bundles.MainnetIds.SPARK_CLOSE_TO_DEBT,
-    strategyId: Strategies.Identifiers.CloseToDebt,
-    protocol: PROTOCOLS.Spark,
-  },
-  [Bundles.MainnetIds.SPARK_CLOSE_TO_COLLATERAL]: {
-    strategyOrBundleId: Bundles.MainnetIds.SPARK_CLOSE_TO_COLLATERAL,
-    strategyId: Strategies.Identifiers.CloseToCollateral,
-    protocol: PROTOCOLS.Spark,
-  },
   [Bundles.MainnetIds.AAVE_V2_REPAY]: {
     strategyOrBundleId: Bundles.MainnetIds.AAVE_V2_REPAY,
     strategyId: Strategies.Identifiers.Repay,
@@ -496,7 +486,16 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.AaveV3,
   },
-
+  [Bundles.MainnetIds.SPARK_CLOSE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_CLOSE,
+    strategyId: Strategies.Identifiers.CloseOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.MORPHO_BLUE_CLOSE]: {
+    strategyOrBundleId: Bundles.MainnetIds.MORPHO_BLUE_CLOSE,
+    strategyId: Strategies.Identifiers.CloseOnPrice,
+    protocol: PROTOCOLS.MorphoBlue,
+  },
 };
 
 export const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo = {
@@ -689,7 +688,11 @@ export const BASE_BUNDLES_INFO: BaseBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.AaveV3,
   },
-
+  [Bundles.BaseIds.MORPHO_BLUE_CLOSE]: {
+    strategyOrBundleId: Bundles.BaseIds.MORPHO_BLUE_CLOSE,
+    strategyId: Strategies.Identifiers.CloseOnPrice,
+    protocol: PROTOCOLS.MorphoBlue,
+  },
 };
 
 export const ARBITRUM_BUNDLES_INFO: ArbitrumBundleInfo = {
@@ -833,6 +836,11 @@ export const ARBITRUM_BUNDLES_INFO: ArbitrumBundleInfo = {
     strategyId: Strategies.Identifiers.EoaBoost,
     protocol: PROTOCOLS.MorphoBlue,
   },
+  [Bundles.ArbitrumIds.MORPHO_BLUE_CLOSE]: {
+    strategyOrBundleId: Bundles.ArbitrumIds.MORPHO_BLUE_CLOSE,
+    strategyId: Strategies.Identifiers.CloseOnPrice,
+    protocol: PROTOCOLS.MorphoBlue,
+  },
 };
 
 export const BUNDLES_INFO: BundlesInfo = {

package/src/services/strategiesService.ts

@@ -17,10 +17,6 @@ import * as triggerService from './triggerService';
 
 const web3 = new Web3();
 
-const SPARK_MARKET_ADDRESSES = {
-  [ChainId.Ethereum]: '0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE',
-};
-
 const AAVE_V3_MARKET_ADDRESSES = {
   [ChainId.Ethereum]: '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e',
   [ChainId.Optimism]: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb',
@@ -791,34 +787,29 @@ function parseSparkCloseOnPrice(position: Position.Automated, parseData: ParseDa
 
   const { subStruct } = parseData.subscriptionEventData;
 
-  const triggerData = triggerService.sparkQuotePriceTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.sparkQuotePriceSubData.decode(subStruct.subData);
+  const triggerData = triggerService.sparkQuotePriceRangeTrigger.decode(subStruct.triggerData);
+  const subData = subDataService.sparkCloseGenericSubData.decode(subStruct.subData);
 
   _position.strategyData.decoded.triggerData = triggerData;
   _position.strategyData.decoded.subData = subData;
 
-  _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, SPARK_MARKET_ADDRESSES[_position.chainId as ChainId.Ethereum]);
+  _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
+
+  const { takeProfitType, stopLossType } = getStopLossAndTakeProfitTypeByCloseStrategyType(+subData.closeType);
 
   _position.specific = {
     collAsset: subData.collAsset,
     collAssetId: subData.collAssetId,
     debtAsset: subData.debtAsset,
     debtAssetId: subData.debtAssetId,
-    baseToken: triggerData.baseTokenAddress,
-    quoteToken: triggerData.quoteTokenAddress,
-    price: triggerData.price,
-    ratioState: triggerData.ratioState,
+    baseToken: triggerData.collToken,
+    quoteToken: triggerData.debtToken,
+    stopLossPrice: triggerData.lowerPrice,
+    takeProfitPrice: triggerData.upperPrice,
+    stopLossType,
+    takeProfitType,
   };
 
-  const { ratioState } = getRatioStateInfoForAaveCloseStrategy(
-    _position.specific.ratioState,
-    wethToEthByAddress(_position.specific.collAsset, parseData.chainId),
-    wethToEthByAddress(_position.specific.debtAsset, parseData.chainId),
-    parseData.chainId,
-  );
-
-  _position.strategy.strategyId = isRatioStateOver(ratioState) ? Strategies.IdOverrides.TakeProfit : Strategies.IdOverrides.StopLoss;
-
   return _position;
 }
 
@@ -999,6 +990,48 @@ function parseMorphoBlueLeverageManagementOnPrice(position: Position.Automated,
   return _position;
 }
 
+function parseMorphoBlueCloseOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
+  const _position = cloneDeep(position);
+
+  const { subStruct } = parseData.subscriptionEventData;
+
+  const triggerData = triggerService.morphoBluePriceRangeTrigger.decode(subStruct.triggerData);
+  const subData = subDataService.morphoBlueCloseOnPriceSubData.decode(subStruct.subData);
+
+  _position.strategyData.decoded.triggerData = triggerData;
+  _position.strategyData.decoded.subData = subData;
+
+  _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, Math.random());
+
+  const marketIdEncodedData = web3.eth.abi.encodeParameters(
+    ['address', 'address', 'address', 'address', 'uint256'],
+    [
+      subData.loanToken,
+      subData.collToken,
+      subData.oracle,
+      subData.irm,
+      subData.lltv,
+    ],
+  );
+
+  const marketId = web3.utils.keccak256(marketIdEncodedData);
+
+  const { takeProfitType, stopLossType } = getStopLossAndTakeProfitTypeByCloseStrategyType(+subData.closeType);
+
+  _position.specific = {
+    subHash: _position.subHash,
+    marketId,
+    collAsset: subData.collToken,
+    debtAsset: subData.loanToken,
+    stopLossPrice: triggerData.lowerPrice,
+    takeProfitPrice: triggerData.upperPrice,
+    stopLossType,
+    takeProfitType,
+  };
+
+  return _position;
+}
+
 function parseLiquityV2CloseOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
 
@@ -1204,8 +1237,7 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
   [ProtocolIdentifiers.StrategiesAutomation.Spark]: {
     [Strategies.Identifiers.Repay]: parseSparkLeverageManagement,
     [Strategies.Identifiers.Boost]: parseSparkLeverageManagement,
-    [Strategies.Identifiers.CloseToDebt]: parseSparkCloseOnPrice,
-    [Strategies.Identifiers.CloseToCollateral]: parseSparkCloseOnPrice,
+    [Strategies.Identifiers.CloseOnPrice]: parseSparkCloseOnPrice,
   },
   [ProtocolIdentifiers.StrategiesAutomation.CrvUSD]: {
     [Strategies.Identifiers.Repay]: parseCrvUSDLeverageManagement,
@@ -1218,6 +1250,7 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
     [Strategies.Identifiers.EoaRepay]: parseMorphoBlueLeverageManagement,
     [Strategies.Identifiers.EoaBoost]: parseMorphoBlueLeverageManagement,
     [Strategies.Identifiers.BoostOnPrice]: parseMorphoBlueLeverageManagementOnPrice,
+    [Strategies.Identifiers.CloseOnPrice]: parseMorphoBlueCloseOnPrice,
   },
   [ProtocolIdentifiers.StrategiesAutomation.FluidT1]: {
     [Strategies.Identifiers.Repay]: parseFluidT1LeverageManagement,

package/src/services/strategySubService.test.ts

@@ -18,8 +18,9 @@ import {
   compoundV3Encode,
   morphoAaveV2Encode,
   exchangeEncode,
-  sparkEncode,
-  crvUSDEncode, compoundV3L2Encode, morphoBlueEncode,
+  crvUSDEncode,
+  compoundV3L2Encode,
+  morphoBlueEncode,
 } from './strategySubService';
 
 describe('Feature: strategySubService.ts', () => {
@@ -1387,97 +1388,6 @@ describe('Feature: strategySubService.ts', () => {
     });
   });
 
-  describe('When testing strategySubService.sparkEncode', () => {
-    describe('leverageManagement()', () => {
-      const examples: Array<[
-        string,
-        [triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean],
-      ]> = [
-        [
-          '0x000000000000000016345785d8a0000000000000000000001e87f85809dc0000000000000000000018fae27693b4000000000000000000001a5e27eef13e000001',
-          [160, 220, 180, 190, true]
-        ],
-        [
-          '0x000000000000000016345785d8a0000000000000000000001bc16d674ec80000000000000000000018fae27693b4000000000000000000001a5e27eef13e000000',
-          [160, 200, 180, 190, false]
-        ],
-      ];
-
-      examples.forEach(([expected, actual]) => {
-        it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-          expect(sparkEncode.leverageManagement(...actual)).to.eql(expected);
-        });
-      });
-    });
-
-    describe('closeToAsset()', () => {
-      const examples: Array<[
-        [StrategyOrBundleIds, boolean, TriggerData, SubData],
-        [
-          strategyOrBundleId: number,
-          isBundle: boolean,
-          triggerData: {
-            baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, ratioState: RatioState
-          },
-          subData: {
-            collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number,
-          },
-        ]
-      ]> = [
-        [
-          [
-            Bundles.MainnetIds.SPARK_CLOSE_TO_COLLATERAL,
-            true,
-            ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000006b175474e89094c44da98b954eedeac495271d0f00000000000000000000000000000000000000000000000000000026e1f9c6000000000000000000000000000000000000000000000000000000000000000000'],
-            [
-              '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', '0x0000000000000000000000000000000000000000000000000000000000000015',
-              '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f', '0x0000000000000000000000000000000000000000000000000000000000000020',
-              '0x0000000000000000000000000000000000000000000000000000000000000000',
-            ],
-          ],
-          [
-            Bundles.MainnetIds.SPARK_CLOSE_TO_COLLATERAL,
-            true,
-            {
-              baseTokenAddress: getAssetInfo('WETH').address, quoteTokenAddress: getAssetInfo('DAI').address, price: 1670, ratioState: RatioState.OVER
-            },
-            {
-              collAsset: getAssetInfo('WETH').address, collAssetId: 21, debtAsset: getAssetInfo('DAI').address, debtAssetId: 32,
-            },
-          ]
-        ],
-        [
-          [
-            Bundles.MainnetIds.SPARK_CLOSE_TO_DEBT,
-            true,
-            ['0x000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f0000000000000000000000000000000000000000000000000000000000084d000000000000000000000000000000000000000000000000000000000000000001'],
-            [
-              '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f', '0x0000000000000000000000000000000000000000000000000000000000000015',
-              '0x000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca', '0x0000000000000000000000000000000000000000000000000000000000000020',
-              '0x0000000000000000000000000000000000000000000000000000000000000000',
-            ],
-          ],
-          [
-            Bundles.MainnetIds.SPARK_CLOSE_TO_DEBT,
-            true,
-            {
-              baseTokenAddress: getAssetInfo('LINK').address, quoteTokenAddress: getAssetInfo('DAI').address, price: 0.00544, ratioState: RatioState.UNDER
-            },
-            {
-              collAsset: getAssetInfo('DAI').address, collAssetId: 21, debtAsset: getAssetInfo('LINK').address, debtAssetId: 32,
-            },
-          ]
-        ]
-      ];
-
-      examples.forEach(([expected, actual]) => {
-        it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-          expect(sparkEncode.closeToAsset(...actual)).to.eql(expected);
-        });
-      });
-    });
-  });
-
   describe('When testing strategySubService.crvUSDEncode', () => {
     describe('leverageManagement()', () => {
       const examples: Array<[
@@ -1581,6 +1491,7 @@ describe('Feature: strategySubService.ts', () => {
       });
     });
   });
+
   describe('When testing strategySubService.morphoBlueEncode', () => {
     describe('leverageManagement()', () => {
       const examples: Array<[
@@ -1676,6 +1587,61 @@ describe('Feature: strategySubService.ts', () => {
         });
       });
     });
+
+    describe('closeOnPrice()', () => {
+      const examples: Array<[
+        [StrategyOrBundleIds, boolean, TriggerData, SubData],
+        [
+          strategyOrBundleId: number,
+          loanToken: EthereumAddress,
+          collToken: EthereumAddress,
+          oracle: EthereumAddress,
+          irm: EthereumAddress,
+          lltv: string,
+          user: EthereumAddress,
+          stopLossPrice: number,
+          stopLossType: CloseToAssetType,
+          takeProfitPrice: number,
+          takeProfitType: CloseToAssetType,
+        ]
+      ]> = [
+        [
+          [
+            Bundles.MainnetIds.MORPHO_BLUE_CLOSE,
+            true,
+             ['0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000022ecb25c000000000000000000000000000000000000000000000000000000005d21dba000'],
+            [
+              '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+              '0x0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
+              '0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc',
+              '0x0000000000000000000000000000000000000000000000000000000000000000',
+              '0x0000000000000000000000000000000000000000000000000d1d507e40be8000',
+              '0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c',
+              '0x0000000000000000000000000000000000000000000000000000000000000005',
+            ],
+          ],
+          [
+            Bundles.MainnetIds.MORPHO_BLUE_CLOSE,
+            web3Utils.toChecksumAddress('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            web3Utils.toChecksumAddress('0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0'),
+            web3Utils.toChecksumAddress('0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC'),
+            web3Utils.toChecksumAddress('0x0000000000000000000000000000000000000000'),
+            '945000000000000000',
+            web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+            1500,
+            CloseToAssetType.DEBT,
+            4000,
+            CloseToAssetType.COLLATERAL
+          ]
+        ],
+      ];
+
+      examples.forEach(([expected, actual]) => {
+        it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+          expect(morphoBlueEncode.closeOnPrice(...actual)).to.eql(expected);
+        });
+      });
+    });
   });
 
   describe('When testing strategySubService.compoundV3L2Encode', () => {
@@ -1709,5 +1675,4 @@ describe('Feature: strategySubService.ts', () => {
       });
     });
   });
-
 });

package/src/services/strategySubService.ts

@@ -557,25 +557,24 @@ export const sparkEncode = {
 
     return subInput;
   },
-  closeToAsset(
+  closeOnPriceGeneric(
     strategyOrBundleId: number,
-    isBundle: boolean = true,
-    triggerData: {
-      baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, ratioState: RatioState
-    },
-    subData: {
-      collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number,
-    },
+    collAsset: EthereumAddress,
+    collAssetId: number,
+    debtAsset: EthereumAddress,
+    debtAssetId: number,
+    marketAddr: EthereumAddress,
+    user: EthereumAddress,
+    stopLossPrice: number = 0,
+    stopLossType: CloseToAssetType = CloseToAssetType.DEBT,
+    takeProfitPrice: number = 0,
+    takeProfitType: CloseToAssetType = CloseToAssetType.COLLATERAL,
   ) {
-    const {
-      collAsset, collAssetId, debtAsset, debtAssetId,
-    } = subData;
-    const subDataEncoded = subDataService.sparkQuotePriceSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId);
+    const isBundle = true;
+    const closeType = getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType);
 
-    const {
-      baseTokenAddress, quoteTokenAddress, price, ratioState,
-    } = triggerData;
-    const triggerDataEncoded = triggerService.sparkQuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, ratioState);
+    const subDataEncoded = subDataService.sparkCloseGenericSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId, closeType, marketAddr, user);
+    const triggerDataEncoded = triggerService.sparkQuotePriceRangeTrigger.encode(collAsset, debtAsset, stopLossPrice, takeProfitPrice);
 
     return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
   },
@@ -671,6 +670,27 @@ export const morphoBlueEncode = {
     const triggerData = triggerService.morphoBluePriceTrigger.encode(oracle, collToken, loanToken, price, priceState);
     return [strategyOrBundleId, isBundle, triggerData, subData];
   },
+  closeOnPrice(
+    strategyOrBundleId: number,
+    loanToken: EthereumAddress,
+    collToken: EthereumAddress,
+    oracle: EthereumAddress,
+    irm: EthereumAddress,
+    lltv: string,
+    user: EthereumAddress,
+    stopLossPrice: number = 0,
+    stopLossType: CloseToAssetType = CloseToAssetType.DEBT,
+    takeProfitPrice: number = 0,
+    takeProfitType: CloseToAssetType = CloseToAssetType.COLLATERAL,
+  ) {
+    const isBundle = true;
+    const closeType = getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType);
+
+    const subDataEncoded = subDataService.morphoBlueCloseOnPriceSubData.encode(loanToken, collToken, oracle, irm, lltv, user, closeType);
+    const triggerDataEncoded = triggerService.morphoBluePriceRangeTrigger.encode(oracle, collToken, loanToken, stopLossPrice, takeProfitPrice);
+
+    return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+  },
 };
 
 export const liquityV2Encode = {