@defisaver/automation-sdk 3.3.10 → 3.3.11-aave-v4-1-dev

package/cjs/types/index.d.ts

@@ -197,8 +197,40 @@ export declare namespace Position {
             stopLossType: CloseToAssetType | undefined;
             takeProfitType: CloseToAssetType | undefined;
         }
+        interface SparkOnPrice extends Base {
+            collAsset: EthereumAddress;
+            collAssetId: number;
+            debtAsset: EthereumAddress;
+            debtAssetId: number;
+            baseToken: EthereumAddress;
+            quoteToken: EthereumAddress;
+            price: string;
+            ratioState: RatioState;
+            ratio: number;
+        }
+        interface CloseBase extends Base {
+            stopLossPrice: string;
+            takeProfitPrice: string;
+            stopLossType: CloseToAssetType | undefined;
+            takeProfitType: CloseToAssetType | undefined;
+        }
+        interface AaveV4LeverageManagementOnPrice extends Base {
+            collAsset: EthereumAddress;
+            collAssetId: number;
+            debtAsset: EthereumAddress;
+            debtAssetId: number;
+            price: string;
+            ratioState: number;
+            ratio: number;
+        }
+        interface AaveV4CloseOnPrice extends CloseBase {
+            collAsset: EthereumAddress;
+            collAssetId: number;
+            debtAsset: EthereumAddress;
+            debtAssetId: number;
+        }
     }
-    type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave | Specific.BoostOnPriceAave | Specific.CloseOnPriceWithMaximumGasPriceAave | Specific.DebtInFrontRepay | Specific.LeverageManagementCrvUSD | Specific.CloseOnPriceLiquityV2 | Specific.BoostOnPriceMorpho | Specific.BoostOnPriceLiquityV2 | Specific.PaybackLiquityV2 | Specific.CompoundV3LeverageManagementOnPrice | Specific.CompoundV3CloseOnPrice | Specific.AaveV3CloseOnPriceGeneric;
+    type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave | Specific.BoostOnPriceAave | Specific.CloseOnPriceWithMaximumGasPriceAave | Specific.DebtInFrontRepay | Specific.LeverageManagementCrvUSD | Specific.CloseOnPriceLiquityV2 | Specific.BoostOnPriceMorpho | Specific.BoostOnPriceLiquityV2 | Specific.PaybackLiquityV2 | Specific.CompoundV3LeverageManagementOnPrice | Specific.CompoundV3CloseOnPrice | Specific.AaveV3CloseOnPriceGeneric | Specific.AaveV4LeverageManagementOnPrice | Specific.AaveV4CloseOnPrice | Specific.SparkOnPrice;
     interface Automated {
         chainId: ChainId;
         positionId: string;

package/esm/automation/private/StrategiesAutomation.d.ts

@@ -25,6 +25,8 @@ export default class StrategiesAutomation extends Automation {
      */
     protected removeExpiredSubscriptions(subscriptions: (Position.Automated | null)[]): (Position.Automated | null)[];
     private _mergeCheck;
+    /** Repay/boost leverage pairs must not merge across different Aave V4 spokes. */
+    private _aaveV4MergeSpokesMatch;
     protected mergeSubs(_subscriptions: (Position.Automated | null)[]): Position.Automated[];
     protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;

package/esm/automation/private/StrategiesAutomation.js

@@ -99,7 +99,16 @@ export default class StrategiesAutomation extends Automation {
             && (s.protocol.id !== ProtocolIdentifiers.StrategiesAutomation.CrvUSD // merge only crvUSD leverage management for the same market
                 || s.strategyData.decoded.subData.controller.toLowerCase() === current.strategyData.decoded.triggerData.controller.toLowerCase())
             && (s.protocol.id !== ProtocolIdentifiers.StrategiesAutomation.MorphoBlue // merge morpho blue with the same marketId
-                || s.strategyData.decoded.triggerData.marketId.toLowerCase() === current.strategyData.decoded.triggerData.marketId.toLowerCase());
+                || s.strategyData.decoded.triggerData.marketId.toLowerCase() === current.strategyData.decoded.triggerData.marketId.toLowerCase())
+            && (s.protocol.id !== ProtocolIdentifiers.StrategiesAutomation.AaveV4
+                || this._aaveV4MergeSpokesMatch(s, current));
+    }
+    /** Repay/boost leverage pairs must not merge across different Aave V4 spokes. */
+    _aaveV4MergeSpokesMatch(s, current) {
+        var _a, _b, _c, _d, _e, _f;
+        const a = (_c = (_b = (_a = s.strategyData) === null || _a === void 0 ? void 0 : _a.decoded) === null || _b === void 0 ? void 0 : _b.triggerData) === null || _c === void 0 ? void 0 : _c.spoke;
+        const b = (_f = (_e = (_d = current.strategyData) === null || _d === void 0 ? void 0 : _d.decoded) === null || _e === void 0 ? void 0 : _e.triggerData) === null || _f === void 0 ? void 0 : _f.spoke;
+        return !!a && !!b && a.toLowerCase() === b.toLowerCase();
     }
     mergeSubs(_subscriptions) {
         const mergeBase = _subscriptions.filter(s => isDefined(s) && isDefined(s.specific.mergeWithId));

package/esm/automation/private/StrategiesAutomation.test.js

@@ -662,5 +662,30 @@ describe('Feature: StrategiesAutomation.ts', () => {
                 expect(JSON.stringify(actual)).to.equal(JSON.stringify(expected));
             }));
         });
+        it('Aave V4: pairs repay/boost merge only when trigger spoke matches (no cross-spoke merge)', () => {
+            var _a, _b, _c;
+            const spoke1 = '0x0000000000000000000000000000000000000a01';
+            const spoke2 = '0x0000000000000000000000000000000000000a02';
+            const base = {
+                isEnabled: true,
+                chainId: 1,
+                owner: '0x0000000000000000000000000000000000000b01',
+                protocol: { id: 'Aave__V4' },
+                strategy: { strategyId: 'leverage-management' },
+                blockNumber: 0,
+                subHash: '0x1',
+                positionId: 'test',
+            };
+            const boostSpoke1 = Object.assign(Object.assign({}, base), { subId: 1, strategyData: { decoded: { triggerData: { spoke: spoke1 }, subData: {} } }, specific: { mergeId: 'boost', subId2: 1 } });
+            const repaySpoke2 = Object.assign(Object.assign({}, base), { subId: 2, strategyData: { decoded: { triggerData: { spoke: spoke2 }, subData: {} } }, specific: { mergeWithId: 'boost', subId1: 2 } });
+            const boostSpoke2 = Object.assign(Object.assign({}, base), { subId: 3, strategyData: { decoded: { triggerData: { spoke: spoke2 }, subData: {} } }, specific: { mergeId: 'boost', subId2: 3 } });
+            // @ts-ignore — mergeSubs is protected; exercised here as in examples above
+            const merged = exampleStrategiesAutomation.mergeSubs([boostSpoke1, repaySpoke2, boostSpoke2]);
+            expect(merged).to.have.length(2);
+            const mergedPair = merged.find((m) => { var _a; return ((_a = m.subIds) === null || _a === void 0 ? void 0 : _a.length) === 2; });
+            const loneBoost = merged.find((m) => { var _a; return ((_a = m.subIds) === null || _a === void 0 ? void 0 : _a.length) === 1; });
+            expect((_c = (_b = (_a = mergedPair === null || mergedPair === void 0 ? void 0 : mergedPair.strategyData) === null || _a === void 0 ? void 0 : _a.decoded) === null || _b === void 0 ? void 0 : _b.triggerData) === null || _c === void 0 ? void 0 : _c.spoke).to.equal(spoke2);
+            expect(loneBoost === null || loneBoost === void 0 ? void 0 : loneBoost.subId).to.equal(1);
+        });
     }));
 });

package/esm/constants/index.d.ts

@@ -1,6 +1,7 @@
 import type { ArbitrumBundleInfo, ArbitrumStrategiesInfo, BundlesInfo, EthereumAddress, Interfaces, MainnetBundleInfo, MainnetStrategiesInfo, OptimismBundleInfo, OptimismStrategiesInfo, BaseBundleInfo, BaseStrategiesInfo, StrategiesInfo } from '../types';
 import { ProtocolIdentifiers, Strategies, Bundles } from '../types/enums';
 export declare const ZERO_ADDRESS: EthereumAddress;
+export declare const EMPTY_SLOT: string;
 export declare const AAVE_V3_VARIABLE_BORROW_RATE = 2;
 export declare const PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.StrategiesAutomation, Interfaces.Protocol>;
 export declare const LEGACY_PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.LegacyAutomation, Interfaces.LegacyProtocol>;

package/esm/constants/index.js

@@ -3,6 +3,7 @@ import Protocol from '../automation/private/Protocol';
 import LegacyProtocol from '../automation/private/LegacyProtocol';
 // General
 export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const EMPTY_SLOT = '0x0000000000000000000000000000000000000000000000000000000000000000';
 export const AAVE_V3_VARIABLE_BORROW_RATE = 2;
 export const PROTOCOLS = (() => {
     const protocolsMapping = {};
@@ -100,6 +101,16 @@ export const MAINNET_STRATEGIES_INFO = {
         strategyId: Strategies.Identifiers.CollateralSwitch,
         protocol: PROTOCOLS.AaveV3,
     },
+    [Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH]: {
+        strategyOrBundleId: Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH,
+        strategyId: Strategies.Identifiers.CollateralSwitch,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA]: {
+        strategyOrBundleId: Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA,
+        strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+        protocol: PROTOCOLS.AaveV4,
+    },
 };
 export const OPTIMISM_STRATEGIES_INFO = {
     [Strategies.OptimismIds.EXCHANGE_DCA]: {
@@ -467,6 +478,66 @@ export const MAINNET_BUNDLES_INFO = {
         strategyId: Strategies.Identifiers.CloseOnPrice,
         protocol: PROTOCOLS.MorphoBlue,
     },
+    [Bundles.MainnetIds.SPARK_REPAY_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.SPARK_REPAY_ON_PRICE,
+        strategyId: Strategies.Identifiers.RepayOnPrice,
+        protocol: PROTOCOLS.Spark,
+    },
+    [Bundles.MainnetIds.SPARK_BOOST_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.SPARK_BOOST_ON_PRICE,
+        strategyId: Strategies.Identifiers.BoostOnPrice,
+        protocol: PROTOCOLS.Spark,
+    },
+    [Bundles.MainnetIds.AAVE_V4_REPAY]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_REPAY,
+        strategyId: Strategies.Identifiers.Repay,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_BOOST]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_BOOST,
+        strategyId: Strategies.Identifiers.Boost,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_REPAY_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_REPAY_ON_PRICE,
+        strategyId: Strategies.Identifiers.RepayOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_BOOST_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_BOOST_ON_PRICE,
+        strategyId: Strategies.Identifiers.BoostOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_CLOSE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_CLOSE,
+        strategyId: Strategies.Identifiers.CloseOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_EOA_REPAY]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_EOA_REPAY,
+        strategyId: Strategies.Identifiers.EoaRepay,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_EOA_BOOST]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_EOA_BOOST,
+        strategyId: Strategies.Identifiers.EoaBoost,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_EOA_REPAY_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_EOA_REPAY_ON_PRICE,
+        strategyId: Strategies.Identifiers.EoaRepayOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_EOA_BOOST_ON_PRICE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_EOA_BOOST_ON_PRICE,
+        strategyId: Strategies.Identifiers.EoaBoostOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
+    [Bundles.MainnetIds.AAVE_V4_EOA_CLOSE]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_EOA_CLOSE,
+        strategyId: Strategies.Identifiers.EoaCloseOnPrice,
+        protocol: PROTOCOLS.AaveV4,
+    },
 };
 export const OPTIMISM_BUNDLES_INFO = {
     [Bundles.OptimismIds.AAVE_V3_REPAY]: {

package/esm/services/ethereumService.test.js

@@ -142,6 +142,7 @@ describe('Feature: ethereumService.ts', () => {
                         'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
                         'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
                         'blockNumber': 5353002,
+                        'blockTimestamp': '0x624c1a5b',
                         'event': 'Transfer',
                         'id': 'log_f49645b8',
                         'logIndex': 1,
@@ -187,6 +188,7 @@ describe('Feature: ethereumService.ts', () => {
                         'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
                         'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
                         'blockNumber': 5353002,
+                        'blockTimestamp': '0x624c1a5b',
                         'event': 'Transfer',
                         'id': 'log_f49645b8',
                         'logIndex': 1,

package/esm/services/strategiesService.js

@@ -2,7 +2,7 @@ import { getAssetInfoByAddress } from '@defisaver/tokens';
 import { cloneDeep } from 'lodash';
 import Web3 from 'web3';
 import { BUNDLES_INFO, STRATEGIES_INFO } from '../constants';
-import { ChainId, ProtocolIdentifiers, Strategies } from '../types/enums';
+import { ChainId, ProtocolIdentifiers, Strategies, } from '../types/enums';
 import { getPositionId, getRatioStateInfoForAaveCloseStrategy, getStopLossAndTakeProfitTypeByCloseStrategyType, isRatioStateOver, wethToEthByAddress, } from './utils';
 import * as subDataService from './subDataService';
 import * as triggerService from './triggerService';
@@ -285,6 +285,96 @@ function parseAaveV3CollateralSwitch(position, parseData) {
     _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
     return _position;
 }
+function parseAaveV4LeverageManagement(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct, subId, subHash } = parseData.subscriptionEventData;
+    const { isEnabled } = parseData.strategiesSubsData;
+    const triggerData = triggerService.aaveV4RatioTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV4LeverageManagementSubData.decode(subStruct.subData);
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    const isRepay = [Strategies.Identifiers.Repay, Strategies.Identifiers.EoaRepay].includes(_position.strategy.strategyId);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? Strategies.IdOverrides.EoaLeverageManagement : Strategies.IdOverrides.LeverageManagement;
+    if (isRepay) {
+        _position.specific = {
+            triggerRepayRatio: triggerData.ratio,
+            targetRepayRatio: subData.targetRatio,
+            repayEnabled: isEnabled,
+            subId1: Number(subId),
+            mergeWithId: isEOA ? Strategies.Identifiers.EoaBoost : Strategies.Identifiers.Boost,
+            subHashRepay: subHash,
+        };
+    }
+    else {
+        _position.specific = {
+            triggerBoostRatio: triggerData.ratio,
+            targetBoostRatio: subData.targetRatio,
+            boostEnabled: isEnabled,
+            subId2: Number(subId),
+            mergeId: isEOA ? Strategies.Identifiers.EoaBoost : Strategies.Identifiers.Boost,
+            subHashBoost: subHash,
+        };
+    }
+    return _position;
+}
+function parseAaveV4LeverageManagementOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.aaveV4QuotePriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV4LeverageManagementOnPriceSubData.decode(subStruct.subData);
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? Strategies.IdOverrides.EoaLeverageManagementOnPrice : Strategies.IdOverrides.LeverageManagementOnPrice;
+    _position.specific = {
+        collAsset: subData.collAsset,
+        collAssetId: subData.collAssetId,
+        debtAsset: subData.debtAsset,
+        debtAssetId: subData.debtAssetId,
+        price: triggerData.price,
+        ratioState: triggerData.ratioState,
+        ratio: subData.targetRatio,
+    };
+    return _position;
+}
+function parseAaveV4CloseOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.aaveV4QuotePriceRangeTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV4CloseSubData.decode(subStruct.subData);
+    const { takeProfitType, stopLossType } = getStopLossAndTakeProfitTypeByCloseStrategyType(+subData.closeType);
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? Strategies.Identifiers.EoaCloseOnPrice : Strategies.Identifiers.CloseOnPrice;
+    _position.specific = {
+        collAsset: subData.collAsset,
+        collAssetId: subData.collAssetId,
+        debtAsset: subData.debtAsset,
+        debtAssetId: subData.debtAssetId,
+        stopLossPrice: triggerData.lowerPrice,
+        takeProfitPrice: triggerData.upperPrice,
+        stopLossType,
+        takeProfitType,
+    };
+    return _position;
+}
+function parseAaveV4CollateralSwitch(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.aaveV4QuotePriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV4CollateralSwitchSubData.decode(subStruct.subData);
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? Strategies.Identifiers.EoaCollateralSwitch : Strategies.Identifiers.CollateralSwitch;
+    return _position;
+}
 function parseMorphoAaveV2LeverageManagement(position, parseData) {
     const _position = cloneDeep(position);
     const { subStruct, subId } = parseData.subscriptionEventData;
@@ -584,6 +674,29 @@ function parseSparkLeverageManagement(position, parseData) {
     _position.strategy.strategyId = Strategies.IdOverrides.LeverageManagement;
     return _position;
 }
+function parseSparkLeverageManagementOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.sparkQuotePriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.sparkLeverageManagementOnPriceSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
+    _position.specific = {
+        // subData
+        collAsset: subData.collAsset,
+        collAssetId: subData.collAssetId,
+        debtAsset: subData.debtAsset,
+        debtAssetId: subData.debtAssetId,
+        ratio: subData.targetRatio,
+        // triggerData
+        baseToken: triggerData.baseTokenAddr,
+        quoteToken: triggerData.quoteTokenAddr,
+        price: triggerData.price,
+        ratioState: triggerData.ratioState,
+    };
+    return _position;
+}
 function parseSparkCloseOnPrice(position, parseData) {
     const _position = cloneDeep(position);
     const { subStruct } = parseData.subscriptionEventData;
@@ -914,6 +1027,20 @@ const parsingMethodsMapping = {
         [Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV3CloseOnPrice,
         [Strategies.Identifiers.CollateralSwitch]: parseAaveV3CollateralSwitch,
     },
+    [ProtocolIdentifiers.StrategiesAutomation.AaveV4]: {
+        [Strategies.Identifiers.Repay]: parseAaveV4LeverageManagement,
+        [Strategies.Identifiers.Boost]: parseAaveV4LeverageManagement,
+        [Strategies.Identifiers.RepayOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [Strategies.Identifiers.BoostOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [Strategies.Identifiers.CloseOnPrice]: parseAaveV4CloseOnPrice,
+        [Strategies.Identifiers.EoaRepay]: parseAaveV4LeverageManagement,
+        [Strategies.Identifiers.EoaBoost]: parseAaveV4LeverageManagement,
+        [Strategies.Identifiers.EoaRepayOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [Strategies.Identifiers.EoaBoostOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV4CloseOnPrice,
+        [Strategies.Identifiers.CollateralSwitch]: parseAaveV4CollateralSwitch,
+        [Strategies.Identifiers.EoaCollateralSwitch]: parseAaveV4CollateralSwitch,
+    },
     [ProtocolIdentifiers.StrategiesAutomation.CompoundV2]: {
         [Strategies.Identifiers.Repay]: parseCompoundV2LeverageManagement,
         [Strategies.Identifiers.Boost]: parseCompoundV2LeverageManagement,
@@ -944,6 +1071,8 @@ const parsingMethodsMapping = {
     [ProtocolIdentifiers.StrategiesAutomation.Spark]: {
         [Strategies.Identifiers.Repay]: parseSparkLeverageManagement,
         [Strategies.Identifiers.Boost]: parseSparkLeverageManagement,
+        [Strategies.Identifiers.RepayOnPrice]: parseSparkLeverageManagementOnPrice,
+        [Strategies.Identifiers.BoostOnPrice]: parseSparkLeverageManagementOnPrice,
         [Strategies.Identifiers.CloseOnPrice]: parseSparkCloseOnPrice,
     },
     [ProtocolIdentifiers.StrategiesAutomation.CrvUSD]: {

package/esm/services/strategySubService.d.ts

@@ -86,6 +86,19 @@ export declare const exchangeEncode: {
 };
 export declare const sparkEncode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string;
+    leverageManagementOnPrice(strategyOrBundleId: number, isBundle: boolean | undefined, triggerData: {
+        baseTokenAddr: EthereumAddress;
+        quoteTokenAddr: EthereumAddress;
+        price: number;
+        ratioState: RatioState;
+    }, subData: {
+        collAsset: EthereumAddress;
+        collAssetId: number;
+        debtAsset: EthereumAddress;
+        debtAssetId: number;
+        marketAddr: EthereumAddress;
+        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[])[];
 };
@@ -107,3 +120,9 @@ export declare const liquityV2Encode: {
 export declare const fluidEncode: {
     leverageManagement(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[])[];
+    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

@@ -243,6 +243,13 @@ export const sparkEncode = {
         subInput = subInput.concat(boostEnabled ? '01' : '00');
         return subInput;
     },
+    leverageManagementOnPrice(strategyOrBundleId, isBundle = true, triggerData, subData) {
+        const { collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio, } = subData;
+        const subDataEncoded = subDataService.sparkLeverageManagementOnPriceSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio);
+        const { baseTokenAddr, quoteTokenAddr, price, ratioState, } = triggerData;
+        const triggerDataEncoded = triggerService.sparkQuotePriceTrigger.encode(baseTokenAddr, quoteTokenAddr, price, ratioState);
+        return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+    },
     closeOnPriceGeneric(strategyOrBundleId, collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, user, stopLossPrice = 0, stopLossType = CloseToAssetType.DEBT, takeProfitPrice = 0, takeProfitType = CloseToAssetType.COLLATERAL) {
         const isBundle = true;
         const closeType = getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType);
@@ -341,3 +348,32 @@ export const fluidEncode = {
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
+export const aaveV4Encode = {
+    leverageManagement(strategyOrBundleId, owner, spoke, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.aaveV4LeverageManagementSubData.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);
+        const triggerData = triggerService.aaveV4QuotePriceTrigger.encode(spoke, collAssetId, debtAssetId, price, priceState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+    closeOnPrice(strategyOrBundleId, owner, spoke, collAsset, collAssetId, debtAsset, debtAssetId, stopLossPrice = '0', stopLossType = CloseToAssetType.DEBT, takeProfitPrice = '0', takeProfitType = CloseToAssetType.COLLATERAL) {
+        const isBundle = true;
+        const closeType = getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType);
+        const subData = subDataService.aaveV4CloseSubData.encode(spoke, owner, collAsset, collAssetId, debtAsset, debtAssetId, closeType);
+        const triggerData = triggerService.aaveV4QuotePriceRangeTrigger.encode(spoke, collAssetId, debtAssetId, stopLossPrice, takeProfitPrice);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+    collateralSwitch(strategyOrBundleId, owner, spoke, fromAsset, fromAssetId, toAsset, toAssetId, amountToSwitch, price, ratioState) {
+        const isBundle = false;
+        const subData = subDataService.aaveV4CollateralSwitchSubData.encode(spoke, owner, fromAsset, fromAssetId, toAsset, toAssetId, amountToSwitch);
+        const triggerData = triggerService.aaveV4QuotePriceTrigger.encode(spoke, fromAssetId, // baseTokenId
+        toAssetId, // quoteTokenId
+        price, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
+};