@defisaver/automation-sdk 3.3.15 → 3.3.16-liq-prot-dev

package/esm/services/strategySubService.d.ts

@@ -1,26 +1,24 @@
-import type { OrderType } from '../types/enums';
-import { CloseToAssetType, Bundles, ChainId, RatioState, Strategies } from '../types/enums';
+import { Bundles, ChainId, CloseToAssetType, RatioState, Strategies } from '../types/enums';
 import type { EthereumAddress, StrategyOrBundleIds } from '../types';
+import type { OrderType } from '../types/enums';
 export declare const makerEncode: {
     repayFromSavings(bundleId: StrategyOrBundleIds, vaultId: number, triggerRepayRatio: number, targetRepayRatio: number, isBundle?: boolean, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds | Strategies.BaseIds | Bundles.MainnetIds | Bundles.OptimismIds | Bundles.ArbitrumIds | Bundles.BaseIds)[];
     closeOnPrice(vaultId: number, ratioState: RatioState, price: string, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
     trailingStop(vaultId: number, triggerPercentage: number, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, roundId: number, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
-    leverageManagementWithoutSubProxy(vaultId: number, triggerRatio: number, targetRatio: number, ratioState: RatioState, isBoost: boolean, daiAddr?: EthereumAddress): (boolean | string[] | Bundles.MainnetIds)[];
+    leverageManagement(vaultId: number, triggerRatio: number, targetRatio: number, ratioState: RatioState, isBoost: boolean, daiAddr?: EthereumAddress): (boolean | string[] | Bundles.MainnetIds)[];
+    liquidationProtection(vaultId: number, triggerRatio: number, targetRatio: number, ratioState: RatioState, daiAddr?: EthereumAddress): (boolean | string[] | Bundles.MainnetIds)[];
 };
 export declare const liquityEncode: {
     closeOnPrice(priceOverOrUnder: RatioState, price: string, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, chainId?: ChainId, collAddr?: EthereumAddress, debtAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
     trailingStop(triggerPercentage: number, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, roundId: number, chainId?: ChainId, collAddr?: EthereumAddress, debtAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
     paybackFromChickenBondStrategySub(proxyAddress: EthereumAddress, ratio: number, sourceId: string, sourceType: number, ratioState?: RatioState): (boolean | string[] | Bundles.MainnetIds)[];
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
     dsrPayback(proxyAddress: EthereumAddress, triggerRatio: number, targetRatio: number): (boolean | string[] | Strategies.MainnetIds)[];
     dsrSupply(proxyAddress: EthereumAddress, triggerRatio: number, targetRatio: number): (boolean | string[] | Strategies.MainnetIds)[];
     debtInFrontRepay(proxyAddress: EthereumAddress, debtInFrontMin: string, targetRatioIncrease: number): (boolean | string[] | Strategies.MainnetIds)[];
 };
-export declare const chickenBondsEncode: {
-    rebond(bondId: number): string[];
-};
 export declare const aaveV2Encode: {
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
 };
 export declare const aaveV3Encode: {
     closeToAsset(strategyOrBundleId: number, isBundle: boolean | undefined, triggerData: {
@@ -59,25 +57,24 @@ export declare const aaveV3Encode: {
         marketAddr: EthereumAddress;
         targetRatio: number;
     }): (number | boolean | string[])[];
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number, isGeneric?: boolean): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number, isGeneric?: boolean): (number | boolean | string[])[];
+    liquidationProtection(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
     leverageManagementOnPriceGeneric(strategyOrBundleId: number, price: number, ratioState: RatioState, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, targetRatio: number, user: EthereumAddress): (number | boolean | string[])[];
     closeOnPriceGeneric(strategyOrBundleId: number, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, user: EthereumAddress, stopLossPrice?: number, stopLossType?: CloseToAssetType, takeProfitPrice?: number, takeProfitType?: CloseToAssetType): (number | boolean | string[])[];
     collateralSwitch(strategyOrBundleId: number, fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, state: RatioState): (number | boolean | string[])[];
 };
 export declare const compoundV2Encode: {
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
 };
 export declare const compoundV3Encode: {
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, baseToken: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, market: EthereumAddress, baseToken: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    liquidationProtection(strategyOrBundleId: number, market: EthereumAddress, baseToken: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
     leverageManagementOnPrice(strategyOrBundleId: number, market: EthereumAddress, collToken: EthereumAddress, baseToken: EthereumAddress, targetRatio: number, price: number, priceState: RatioState, ratioState: RatioState, user: EthereumAddress): (number | boolean | string[])[];
     closeOnPrice(strategyOrBundleId: number, market: EthereumAddress, collToken: EthereumAddress, baseToken: EthereumAddress, stopLossPrice: number | undefined, stopLossType: CloseToAssetType | undefined, takeProfitPrice: number | undefined, takeProfitType: CloseToAssetType | undefined, user: EthereumAddress): (number | boolean | string[])[];
 };
-export declare const morphoAaveV2Encode: {
-    leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string[];
-};
 export declare const exchangeEncode: {
     dca(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, timestamp: number, interval: number, network: ChainId): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds | Strategies.BaseIds)[];
-    limitOrderWithoutSubProxy(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, targetPrice: string, goodUntil: string | number, orderType: OrderType, fromTokenDecimals: number, toTokenDecimals: number, network: ChainId): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds | Strategies.BaseIds)[];
+    limitOrder(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, targetPrice: string, goodUntil: string | number, orderType: OrderType, fromTokenDecimals: number, toTokenDecimals: number, network: ChainId): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds | Strategies.BaseIds)[];
 };
 export declare const sparkEncode: {
     leverageManagementOnPrice(strategyOrBundleId: number, isBundle: boolean | undefined, triggerData: {
@@ -94,7 +91,8 @@ export declare const sparkEncode: {
         targetRatio: number;
     }): (number | boolean | string[])[];
     closeOnPriceGeneric(strategyOrBundleId: number, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, user: EthereumAddress, stopLossPrice?: number, stopLossType?: CloseToAssetType, takeProfitPrice?: number, takeProfitType?: CloseToAssetType): (number | boolean | string[])[];
-    leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    leverageManagement(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    liquidationProtection(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
     collateralSwitch(strategyOrBundleId: number, fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, state: RatioState): (number | boolean | string[])[];
 };
 export declare const crvUSDEncode: {
@@ -103,6 +101,7 @@ export declare const crvUSDEncode: {
 };
 export declare const morphoBlueEncode: {
     leverageManagement(marketId: string, loanToken: EthereumAddress, collToken: EthereumAddress, oracle: EthereumAddress, irm: EthereumAddress, lltv: string, ratioState: RatioState, targetRatio: number, triggerRatio: number, user: EthereumAddress, isEOA: boolean, network: ChainId): (boolean | string[] | Bundles.BaseIds)[] | (boolean | string[] | Bundles.MainnetIds | Bundles.ArbitrumIds)[];
+    liquidationProtection(marketId: string, loanToken: EthereumAddress, collToken: EthereumAddress, oracle: EthereumAddress, irm: EthereumAddress, lltv: string, ratioState: RatioState, targetRatio: number, triggerRatio: number, user: EthereumAddress, isEOA: boolean, network: ChainId): (boolean | string[] | Bundles.MainnetIds)[];
     leverageManagementOnPrice(strategyOrBundleId: number, isBundle: boolean | undefined, loanToken: EthereumAddress, collToken: EthereumAddress, oracle: EthereumAddress, irm: EthereumAddress, lltv: string, user: EthereumAddress, targetRatio: number, price: number, priceState: RatioState): (number | boolean | string[])[];
     closeOnPrice(strategyOrBundleId: number, loanToken: EthereumAddress, collToken: EthereumAddress, oracle: EthereumAddress, irm: EthereumAddress, lltv: string, user: EthereumAddress, stopLossPrice?: number, stopLossType?: CloseToAssetType, takeProfitPrice?: number, takeProfitType?: CloseToAssetType): (number | boolean | string[])[];
 };
@@ -114,9 +113,11 @@ export declare const liquityV2Encode: {
 };
 export declare const fluidEncode: {
     leverageManagement(nftId: string, vault: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number, strategyOrBundleId: number): (number | boolean | string[])[];
+    liquidationProtection(nftId: string, vault: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number, strategyOrBundleId: number): (number | boolean | string[])[];
 };
 export declare const aaveV4Encode: {
     leverageManagement(strategyOrBundleId: number, owner: EthereumAddress, spoke: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
+    liquidationProtection(strategyOrBundleId: number, owner: EthereumAddress, spoke: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
     leverageManagementOnPrice(strategyOrBundleId: number, owner: EthereumAddress, spoke: EthereumAddress, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, targetRatio: number, price: string, priceState: RatioState, ratioState: RatioState): (number | boolean | string[])[];
     closeOnPrice(strategyOrBundleId: number, owner: EthereumAddress, spoke: EthereumAddress, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, stopLossPrice?: string, stopLossType?: CloseToAssetType, takeProfitPrice?: string, takeProfitType?: CloseToAssetType): (number | boolean | string[])[];
     collateralSwitch(strategyOrBundleId: number, owner: EthereumAddress, spoke: EthereumAddress, fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, amountToSwitch: string, price: string, ratioState: RatioState): (number | boolean | string[])[];

package/esm/services/strategySubService.js

@@ -1,9 +1,9 @@
 import { getAssetInfo } from '@defisaver/tokens';
-import { CloseToAssetType, Bundles, ChainId, RatioState, Strategies, } from '../types/enums';
 import { STRATEGY_IDS } from '../constants';
+import { Bundles, ChainId, CloseToAssetType, RatioState, Strategies, } from '../types/enums';
 import * as subDataService from './subDataService';
 import * as triggerService from './triggerService';
-import { compareAddresses, getCloseStrategyType, requireAddress, requireAddresses, } from './utils';
+import { compareAddresses, getBundleIdsByNetwork, getCloseStrategyType, requireAddress, requireAddresses, } from './utils';
 export const makerEncode = {
     repayFromSavings(bundleId, vaultId, triggerRepayRatio, targetRepayRatio, isBundle = true, chainId = ChainId.Ethereum, daiAddr, mcdCdpManagerAddr) {
         const subData = subDataService.makerRepayFromSavingsSubData.encode(vaultId, targetRepayRatio, chainId, daiAddr, mcdCdpManagerAddr);
@@ -30,10 +30,21 @@ export const makerEncode = {
         const isBundle = false;
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
-    leverageManagementWithoutSubProxy(vaultId, triggerRatio, targetRatio, ratioState, isBoost, daiAddr) {
+    leverageManagement(vaultId, triggerRatio, targetRatio, ratioState, isBoost, daiAddr) {
         const bundleId = isBoost ? Bundles.MainnetIds.MAKER_BOOST : Bundles.MainnetIds.MAKER_REPAY;
         const triggerData = triggerService.makerRatioTrigger.encode(vaultId, triggerRatio, ratioState);
-        const subData = subDataService.makerLeverageManagementWithoutSubProxy.encode(vaultId, targetRatio, daiAddr);
+        const subData = subDataService.makerLeverageManagementSubData.encode(vaultId, targetRatio, daiAddr);
+        return [
+            bundleId,
+            true,
+            triggerData,
+            subData,
+        ];
+    },
+    liquidationProtection(vaultId, triggerRatio, targetRatio, ratioState, daiAddr) {
+        const bundleId = Bundles.MainnetIds.MAKER_SW_LIQUIDATION_PROTECTION;
+        const triggerData = triggerService.makerRatioTrigger.encode(vaultId, triggerRatio, ratioState);
+        const subData = subDataService.makerLiquidationProtectionSubData.encode(vaultId, targetRatio, daiAddr);
         return [
             bundleId,
             true,
@@ -67,9 +78,9 @@ export const liquityEncode = {
         const isBundle = true;
         return [strategyId, isBundle, triggerData, subData];
     },
-    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+    leverageManagement(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.liquityLeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const subData = subDataService.liquityLeverageManagementSubData.encode(targetRatio, ratioState);
         const triggerData = triggerService.liquityRatioTrigger.encode(user, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
@@ -98,15 +109,10 @@ export const liquityEncode = {
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
-export const chickenBondsEncode = {
-    rebond(bondId) {
-        return subDataService.cBondsRebondSubData.encode(bondId);
-    },
-};
 export const aaveV2Encode = {
-    leverageManagementWithoutSubProxy(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
+    leverageManagement(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.aaveV2LeverageManagementSubDataWithoutSubProxy.encode(market, targetRatio, ratioState);
+        const subData = subDataService.aaveV2LeverageManagementSubData.encode(market, targetRatio, ratioState);
         const triggerData = triggerService.aaveV2RatioTrigger.encode(user, market, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
@@ -133,9 +139,15 @@ export const aaveV3Encode = {
         const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
         return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
     },
-    leverageManagementWithoutSubProxy(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio, isGeneric = false) {
+    leverageManagement(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio, isGeneric = false) {
+        const isBundle = true;
+        const subData = subDataService.aaveV3LeverageManagementSubData.encode(targetRatio, ratioState, market, user, isGeneric);
+        const triggerData = triggerService.aaveV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+    liquidationProtection(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.aaveV3LeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState, market, user, isGeneric);
+        const subData = subDataService.aaveV3LiquidationProtectionSubData.encode(targetRatio, ratioState, market, user, true);
         const triggerData = triggerService.aaveV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
@@ -160,17 +172,23 @@ export const aaveV3Encode = {
     },
 };
 export const compoundV2Encode = {
-    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+    leverageManagement(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.compoundV2LeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const subData = subDataService.compoundV2LeverageManagementSubData.encode(targetRatio, ratioState);
         const triggerData = triggerService.compoundV2RatioTrigger.encode(user, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
 export const compoundV3Encode = {
-    leverageManagementWithoutSubProxy(strategyOrBundleId, market, baseToken, user, ratioState, targetRatio, triggerRatio) {
+    leverageManagement(strategyOrBundleId, market, baseToken, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.compoundV3LeverageManagementSubData.encode(market, baseToken, targetRatio, ratioState);
+        const triggerData = triggerService.compoundV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+    liquidationProtection(strategyOrBundleId, market, baseToken, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.compoundV3LeverageManagementSubDataWithoutSubProxy.encode(market, baseToken, targetRatio, ratioState);
+        const subData = subDataService.compoundV3LiquidationProtectionSubData.encode(market, baseToken, targetRatio, ratioState);
         const triggerData = triggerService.compoundV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
@@ -189,11 +207,6 @@ export const compoundV3Encode = {
         return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
     },
 };
-export const morphoAaveV2Encode = {
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        return subDataService.morphoAaveV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
-    },
-};
 export const exchangeEncode = {
     dca(fromToken, toToken, amount, timestamp, interval, network) {
         requireAddresses([fromToken, toToken]);
@@ -202,9 +215,9 @@ export const exchangeEncode = {
         const strategyId = STRATEGY_IDS[network].EXCHANGE_DCA;
         return [strategyId, false, triggerData, subData];
     },
-    limitOrderWithoutSubProxy(fromToken, toToken, amount, targetPrice, goodUntil, orderType, fromTokenDecimals, toTokenDecimals, network) {
+    limitOrder(fromToken, toToken, amount, targetPrice, goodUntil, orderType, fromTokenDecimals, toTokenDecimals, network) {
         requireAddresses([fromToken, toToken]);
-        const subData = subDataService.exchangeLimitOrderSubDataWithoutSubProxy.encode(fromToken, toToken, amount);
+        const subData = subDataService.exchangeLimitOrderSubData.encode(fromToken, toToken, amount);
         const triggerData = triggerService.exchangeOffchainPriceTrigger.encode(targetPrice, Number(goodUntil), orderType, fromTokenDecimals, toTokenDecimals);
         const strategyId = STRATEGY_IDS[network].EXCHANGE_LIMIT_ORDER;
         return [strategyId, false, triggerData, subData];
@@ -225,9 +238,15 @@ export const sparkEncode = {
         const triggerDataEncoded = triggerService.sparkQuotePriceRangeTrigger.encode(collAsset, debtAsset, stopLossPrice, takeProfitPrice);
         return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
     },
-    leverageManagementWithoutSubProxy(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
+    leverageManagement(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
         const isBundle = true;
-        const subData = subDataService.sparkLeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const subData = subDataService.sparkLeverageManagementSubData.encode(targetRatio, ratioState);
+        const triggerData = triggerService.sparkRatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+    liquidationProtection(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.sparkLiquidationProtectionSubData.encode(targetRatio, ratioState);
         const triggerData = triggerService.sparkRatioTrigger.encode(user, market, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
@@ -273,6 +292,16 @@ export const morphoBlueEncode = {
         const isBundle = true;
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
+    liquidationProtection(marketId, loanToken, collToken, oracle, irm, lltv, ratioState, targetRatio, triggerRatio, user, isEOA, network) {
+        const subData = subDataService.morphoBlueLiquidationProtectionSubData.encode(loanToken, collToken, oracle, irm, lltv, ratioState, targetRatio, user, isEOA);
+        const triggerData = triggerService.morphoBlueRatioTrigger.encode(marketId, user, triggerRatio, ratioState);
+        // Type casting because there is no MORPHO_BLUE_EOA_LIQUIDATION_PROTECTION for Base chain.
+        // That is fine because we will just always send isEOA == false for Base chain.
+        const bundleNetwork = getBundleIdsByNetwork(network);
+        const bundleId = isEOA ? bundleNetwork.MORPHO_BLUE_EOA_LIQUIDATION_PROTECTION : bundleNetwork.MORPHO_BLUE_SW_LIQUIDATION_PROTECTION;
+        const isBundle = true;
+        return [bundleId, isBundle, triggerData, subData];
+    },
     leverageManagementOnPrice(strategyOrBundleId, isBundle = true, loanToken, collToken, oracle, irm, lltv, user, targetRatio, price, priceState) {
         const subData = subDataService.morphoBlueLeverageManagementOnPriceSubData.encode(loanToken, collToken, oracle, irm, lltv, targetRatio, user);
         const triggerData = triggerService.morphoBluePriceTrigger.encode(oracle, collToken, loanToken, price, priceState);
@@ -321,6 +350,12 @@ export const fluidEncode = {
         const triggerData = triggerService.fluidRatioTrigger.encode(nftId, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
+    liquidationProtection(nftId, vault, ratioState, targetRatio, triggerRatio, strategyOrBundleId) {
+        const isBundle = true;
+        const subData = subDataService.fluidLiquidationProtectionSubData.encode(nftId, vault, ratioState, targetRatio);
+        const triggerData = triggerService.fluidRatioTrigger.encode(nftId, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
 };
 export const aaveV4Encode = {
     leverageManagement(strategyOrBundleId, owner, spoke, ratioState, targetRatio, triggerRatio) {
@@ -329,6 +364,12 @@ export const aaveV4Encode = {
         const triggerData = triggerService.aaveV4RatioTrigger.encode(owner, spoke, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
+    liquidationProtection(strategyOrBundleId, owner, spoke, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.aaveV4LiquidationProtectionSubData.encode(spoke, owner, ratioState, targetRatio);
+        const triggerData = triggerService.aaveV4RatioTrigger.encode(owner, spoke, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
     leverageManagementOnPrice(strategyOrBundleId, owner, spoke, collAsset, collAssetId, debtAsset, debtAssetId, targetRatio, price, priceState, ratioState) {
         const isBundle = true;
         const subData = subDataService.aaveV4LeverageManagementOnPriceSubData.encode(spoke, owner, collAsset, collAssetId, debtAsset, debtAssetId, ratioState, targetRatio);

package/esm/services/strategySubService.test.js

@@ -1,11 +1,10 @@
 import { expect } from 'chai';
-import Dec from 'decimal.js';
 import { otherAddresses } from '@defisaver/sdk';
 import { getAssetInfo, MAXUINT } from '@defisaver/tokens';
 import * as web3Utils from 'web3-utils';
 import { Bundles, ChainId, CloseToAssetType, RatioState, Strategies } from '../types/enums';
 import '../configuration';
-import { chickenBondsEncode, liquityEncode, makerEncode, aaveV3Encode, compoundV3Encode, morphoAaveV2Encode, exchangeEncode, crvUSDEncode, morphoBlueEncode, sparkEncode, aaveV4Encode, } from './strategySubService';
+import { liquityEncode, makerEncode, aaveV3Encode, compoundV3Encode, exchangeEncode, crvUSDEncode, morphoBlueEncode, sparkEncode, aaveV4Encode, } from './strategySubService';
 describe('Feature: strategySubService.ts', () => {
     describe('When testing strategySubService.makerEncode', () => {
         // @ts-ignore // TODO - this requires change in @defisaver/tokens
@@ -96,7 +95,7 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
-        describe('leverageManagementWithoutSubProxy()', () => {
+        describe('leverageManagement()', () => {
             const examples = [
                 // Repay scenario (isBoost=false, RatioState.UNDER)
                 [
@@ -139,7 +138,7 @@ describe('Feature: strategySubService.ts', () => {
             ];
             examples.forEach(([expected, actual]) => {
                 it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(makerEncode.leverageManagementWithoutSubProxy(...actual)).to.eql(expected);
+                    expect(makerEncode.leverageManagement(...actual)).to.eql(expected);
                 });
             });
         });
@@ -266,21 +265,6 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
-    describe('When testing strategySubService.chickenBondsEncode', () => {
-        describe('rebond()', () => {
-            const examples = [
-                [
-                    ['0x00000000000000000000000000000000000000000000000000000000000005e3'],
-                    [1507]
-                ]
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(chickenBondsEncode.rebond(...actual)).to.eql(expected);
-                });
-            });
-        });
-    });
     describe('When testing strategySubService.aaveV3Encode', () => {
         describe('closeToAsset()', () => {
             const examples = [
@@ -970,25 +954,6 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
-    describe('When testing strategySubService.morphoAaveV2Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(220).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), true],
-                    [160, 220, 180, 190, true]
-                ],
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(200).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), false],
-                    [160, 200, 180, 190, false]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(morphoAaveV2Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
-    });
     describe('When testing strategySubService.exchangeEncode', () => {
         describe('dca()', () => {
             const examples = [
@@ -1197,6 +1162,73 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
+        describe('leverageManagementOnPrice()', () => {
+            const examples = [
+                [
+                    [
+                        Bundles.MainnetIds.MORPHO_BLUE_REPAY_ON_PRICE,
+                        true,
+                        ['0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000000000000000000000000000000003a352944000000000000000000000000000000000000000000000000000000000000000001'],
+                        [
+                            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
+                            '0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x0000000000000000000000000000000000000000000000000d1d507e40be8000',
+                            '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+                            '0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c',
+                        ],
+                    ],
+                    [
+                        Bundles.MainnetIds.MORPHO_BLUE_REPAY_ON_PRICE,
+                        true,
+                        web3Utils.toChecksumAddress('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+                        web3Utils.toChecksumAddress('0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0'),
+                        web3Utils.toChecksumAddress('0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC'),
+                        web3Utils.toChecksumAddress('0x0000000000000000000000000000000000000000'),
+                        '945000000000000000',
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        200,
+                        2500,
+                        RatioState.UNDER,
+                    ],
+                ],
+                [
+                    [
+                        Bundles.MainnetIds.MORPHO_BLUE_BOOST_ON_PRICE,
+                        true,
+                        ['0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000000000000000000000000000000005d21dba0000000000000000000000000000000000000000000000000000000000000000000'],
+                        [
+                            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
+                            '0x000000000000000000000000870ac11d48b15db9a138cf899d20f13f79ba00bc',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x0000000000000000000000000000000000000000000000000d1d507e40be8000',
+                            '0x00000000000000000000000000000000000000000000000016345785d8a00000',
+                            '0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c',
+                        ],
+                    ],
+                    [
+                        Bundles.MainnetIds.MORPHO_BLUE_BOOST_ON_PRICE,
+                        true,
+                        web3Utils.toChecksumAddress('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+                        web3Utils.toChecksumAddress('0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0'),
+                        web3Utils.toChecksumAddress('0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC'),
+                        web3Utils.toChecksumAddress('0x0000000000000000000000000000000000000000'),
+                        '945000000000000000',
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        160,
+                        4000,
+                        RatioState.OVER,
+                    ],
+                ],
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(morphoBlueEncode.leverageManagementOnPrice(...actual)).to.eql(expected);
+                });
+            });
+        });
         describe('closeOnPrice()', () => {
             const examples = [
                 [