@defisaver/automation-sdk 3.3.11 → 3.3.12-strategies-refactor-dev

package/cjs/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/cjs/automation/private/StrategiesAutomation.js

@@ -104,7 +104,16 @@ class StrategiesAutomation extends Automation_1.default {
             && (s.protocol.id !== enums_1.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 !== enums_1.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 !== enums_1.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 => (0, utils_1.isDefined)(s) && (0, utils_1.isDefined)(s.specific.mergeWithId));

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

@@ -667,5 +667,30 @@ describe('Feature: StrategiesAutomation.ts', () => {
                 (0, chai_1.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]);
+            (0, chai_1.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; });
+            (0, chai_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);
+            (0, chai_1.expect)(loneBoost === null || loneBoost === void 0 ? void 0 : loneBoost.subId).to.equal(1);
+        });
     }));
 });

package/cjs/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/cjs/constants/index.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUNDLE_IDS = exports.BUNDLES_INFO = exports.ARBITRUM_BUNDLES_INFO = exports.BASE_BUNDLES_INFO = exports.OPTIMISM_BUNDLES_INFO = exports.MAINNET_BUNDLES_INFO = exports.STRATEGY_IDS = exports.STRATEGIES_INFO = exports.ARBITRUM_STRATEGIES_INFO = exports.BASE_STRATEGIES_INFO = exports.OPTIMISM_STRATEGIES_INFO = exports.MAINNET_STRATEGIES_INFO = exports.LEGACY_PROTOCOLS = exports.PROTOCOLS = exports.AAVE_V3_VARIABLE_BORROW_RATE = exports.ZERO_ADDRESS = void 0;
+exports.BUNDLE_IDS = exports.BUNDLES_INFO = exports.ARBITRUM_BUNDLES_INFO = exports.BASE_BUNDLES_INFO = exports.OPTIMISM_BUNDLES_INFO = exports.MAINNET_BUNDLES_INFO = exports.STRATEGY_IDS = exports.STRATEGIES_INFO = exports.ARBITRUM_STRATEGIES_INFO = exports.BASE_STRATEGIES_INFO = exports.OPTIMISM_STRATEGIES_INFO = exports.MAINNET_STRATEGIES_INFO = exports.LEGACY_PROTOCOLS = exports.PROTOCOLS = exports.AAVE_V3_VARIABLE_BORROW_RATE = exports.EMPTY_SLOT = exports.ZERO_ADDRESS = void 0;
 const enums_1 = require("../types/enums");
 const Protocol_1 = __importDefault(require("../automation/private/Protocol"));
 const LegacyProtocol_1 = __importDefault(require("../automation/private/LegacyProtocol"));
 // General
 exports.ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+exports.EMPTY_SLOT = '0x0000000000000000000000000000000000000000000000000000000000000000';
 exports.AAVE_V3_VARIABLE_BORROW_RATE = 2;
 exports.PROTOCOLS = (() => {
     const protocolsMapping = {};
@@ -106,6 +107,16 @@ exports.MAINNET_STRATEGIES_INFO = {
         strategyId: enums_1.Strategies.Identifiers.CollateralSwitch,
         protocol: exports.PROTOCOLS.AaveV3,
     },
+    [enums_1.Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH]: {
+        strategyOrBundleId: enums_1.Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH,
+        strategyId: enums_1.Strategies.Identifiers.CollateralSwitch,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA]: {
+        strategyOrBundleId: enums_1.Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA,
+        strategyId: enums_1.Strategies.Identifiers.EoaCollateralSwitch,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
 };
 exports.OPTIMISM_STRATEGIES_INFO = {
     [enums_1.Strategies.OptimismIds.EXCHANGE_DCA]: {
@@ -483,6 +494,56 @@ exports.MAINNET_BUNDLES_INFO = {
         strategyId: enums_1.Strategies.Identifiers.BoostOnPrice,
         protocol: exports.PROTOCOLS.Spark,
     },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_REPAY]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_REPAY,
+        strategyId: enums_1.Strategies.Identifiers.Repay,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_BOOST]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_BOOST,
+        strategyId: enums_1.Strategies.Identifiers.Boost,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_REPAY_ON_PRICE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_REPAY_ON_PRICE,
+        strategyId: enums_1.Strategies.Identifiers.RepayOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_BOOST_ON_PRICE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_BOOST_ON_PRICE,
+        strategyId: enums_1.Strategies.Identifiers.BoostOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_CLOSE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_CLOSE,
+        strategyId: enums_1.Strategies.Identifiers.CloseOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_EOA_REPAY]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_EOA_REPAY,
+        strategyId: enums_1.Strategies.Identifiers.EoaRepay,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_EOA_BOOST]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_EOA_BOOST,
+        strategyId: enums_1.Strategies.Identifiers.EoaBoost,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_EOA_REPAY_ON_PRICE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_EOA_REPAY_ON_PRICE,
+        strategyId: enums_1.Strategies.Identifiers.EoaRepayOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_EOA_BOOST_ON_PRICE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_EOA_BOOST_ON_PRICE,
+        strategyId: enums_1.Strategies.Identifiers.EoaBoostOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
+    [enums_1.Bundles.MainnetIds.AAVE_V4_EOA_CLOSE]: {
+        strategyOrBundleId: enums_1.Bundles.MainnetIds.AAVE_V4_EOA_CLOSE,
+        strategyId: enums_1.Strategies.Identifiers.EoaCloseOnPrice,
+        protocol: exports.PROTOCOLS.AaveV4,
+    },
 };
 exports.OPTIMISM_BUNDLES_INFO = {
     [enums_1.Bundles.OptimismIds.AAVE_V3_REPAY]: {

package/cjs/services/strategiesService.js

@@ -314,6 +314,96 @@ function parseAaveV3CollateralSwitch(position, parseData) {
     _position.positionId = (0, utils_1.getPositionId)(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
     return _position;
 }
+function parseAaveV4LeverageManagement(position, parseData) {
+    const _position = (0, lodash_1.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 = [enums_1.Strategies.Identifiers.Repay, enums_1.Strategies.Identifiers.EoaRepay].includes(_position.strategy.strategyId);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = (0, utils_1.getPositionId)(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? enums_1.Strategies.IdOverrides.EoaLeverageManagement : enums_1.Strategies.IdOverrides.LeverageManagement;
+    if (isRepay) {
+        _position.specific = {
+            triggerRepayRatio: triggerData.ratio,
+            targetRepayRatio: subData.targetRatio,
+            repayEnabled: isEnabled,
+            subId1: Number(subId),
+            mergeWithId: isEOA ? enums_1.Strategies.Identifiers.EoaBoost : enums_1.Strategies.Identifiers.Boost,
+            subHashRepay: subHash,
+        };
+    }
+    else {
+        _position.specific = {
+            triggerBoostRatio: triggerData.ratio,
+            targetBoostRatio: subData.targetRatio,
+            boostEnabled: isEnabled,
+            subId2: Number(subId),
+            mergeId: isEOA ? enums_1.Strategies.Identifiers.EoaBoost : enums_1.Strategies.Identifiers.Boost,
+            subHashBoost: subHash,
+        };
+    }
+    return _position;
+}
+function parseAaveV4LeverageManagementOnPrice(position, parseData) {
+    const _position = (0, lodash_1.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 = (0, utils_1.getPositionId)(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? enums_1.Strategies.IdOverrides.EoaLeverageManagementOnPrice : enums_1.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 = (0, lodash_1.cloneDeep)(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.aaveV4QuotePriceRangeTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV4CloseSubData.decode(subStruct.subData);
+    const { takeProfitType, stopLossType } = (0, utils_1.getStopLossAndTakeProfitTypeByCloseStrategyType)(+subData.closeType);
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.positionId = (0, utils_1.getPositionId)(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? enums_1.Strategies.Identifiers.EoaCloseOnPrice : enums_1.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 = (0, lodash_1.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 = (0, utils_1.getPositionId)(_position.chainId, _position.protocol.id, _position.owner, triggerData.spoke);
+    _position.strategy.strategyId = isEOA ? enums_1.Strategies.Identifiers.EoaCollateralSwitch : enums_1.Strategies.Identifiers.CollateralSwitch;
+    return _position;
+}
 function parseMorphoAaveV2LeverageManagement(position, parseData) {
     const _position = (0, lodash_1.cloneDeep)(position);
     const { subStruct, subId } = parseData.subscriptionEventData;
@@ -966,6 +1056,20 @@ const parsingMethodsMapping = {
         [enums_1.Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV3CloseOnPrice,
         [enums_1.Strategies.Identifiers.CollateralSwitch]: parseAaveV3CollateralSwitch,
     },
+    [enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV4]: {
+        [enums_1.Strategies.Identifiers.Repay]: parseAaveV4LeverageManagement,
+        [enums_1.Strategies.Identifiers.Boost]: parseAaveV4LeverageManagement,
+        [enums_1.Strategies.Identifiers.RepayOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [enums_1.Strategies.Identifiers.BoostOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [enums_1.Strategies.Identifiers.CloseOnPrice]: parseAaveV4CloseOnPrice,
+        [enums_1.Strategies.Identifiers.EoaRepay]: parseAaveV4LeverageManagement,
+        [enums_1.Strategies.Identifiers.EoaBoost]: parseAaveV4LeverageManagement,
+        [enums_1.Strategies.Identifiers.EoaRepayOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [enums_1.Strategies.Identifiers.EoaBoostOnPrice]: parseAaveV4LeverageManagementOnPrice,
+        [enums_1.Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV4CloseOnPrice,
+        [enums_1.Strategies.Identifiers.CollateralSwitch]: parseAaveV4CollateralSwitch,
+        [enums_1.Strategies.Identifiers.EoaCollateralSwitch]: parseAaveV4CollateralSwitch,
+    },
     [enums_1.ProtocolIdentifiers.StrategiesAutomation.CompoundV2]: {
         [enums_1.Strategies.Identifiers.Repay]: parseCompoundV2LeverageManagement,
         [enums_1.Strategies.Identifiers.Boost]: parseCompoundV2LeverageManagement,

package/cjs/services/strategySubService.d.ts

@@ -13,6 +13,7 @@ export declare const liquityEncode: {
     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)[];
     leverageManagement(triggerRepayRatio: string, triggerBoostRatio: string, targetBoostRatio: string, targetRepayRatio: string, boostEnabled: boolean): (string | boolean)[];
+    leverageManagementWithoutSubProxy(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)[];
@@ -22,6 +23,7 @@ export declare const chickenBondsEncode: {
 };
 export declare const aaveV2Encode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string[];
+    leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
 };
 export declare const aaveV3Encode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string;
@@ -68,9 +70,11 @@ export declare const aaveV3Encode: {
 };
 export declare const compoundV2Encode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string[];
+    leverageManagementWithoutSubProxy(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
 };
 export declare const compoundV3Encode: {
     leverageManagement(market: EthereumAddress, baseToken: EthereumAddress, triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean, isEOA: boolean): string[];
+    leverageManagementWithoutSubProxy(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[])[];
 };
@@ -83,6 +87,7 @@ export declare const morphoAaveV2Encode: {
 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)[];
     limitOrder(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, targetPrice: string, goodUntil: string | number, orderType: OrderType): string[];
+    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)[];
 };
 export declare const sparkEncode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string;
@@ -120,3 +125,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/cjs/services/strategySubService.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fluidEncode = exports.liquityV2Encode = exports.morphoBlueEncode = exports.crvUSDEncode = exports.sparkEncode = exports.exchangeEncode = exports.morphoAaveV2Encode = exports.compoundV3L2Encode = exports.compoundV3Encode = exports.compoundV2Encode = exports.aaveV3Encode = exports.aaveV2Encode = exports.chickenBondsEncode = exports.liquityEncode = exports.makerEncode = void 0;
+exports.aaveV4Encode = exports.fluidEncode = exports.liquityV2Encode = exports.morphoBlueEncode = exports.crvUSDEncode = exports.sparkEncode = exports.exchangeEncode = exports.morphoAaveV2Encode = exports.compoundV3L2Encode = exports.compoundV3Encode = exports.compoundV2Encode = exports.aaveV3Encode = exports.aaveV2Encode = exports.chickenBondsEncode = exports.liquityEncode = exports.makerEncode = void 0;
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const tokens_1 = require("@defisaver/tokens");
 const enums_1 = require("../types/enums");
@@ -116,6 +116,12 @@ exports.liquityEncode = {
             boostEnabled,
         ];
     },
+    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.liquityLeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const triggerData = triggerService.liquityRatioTrigger.encode(user, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
     dsrPayback(proxyAddress, triggerRatio, targetRatio) {
         (0, utils_1.requireAddress)(proxyAddress);
         const subData = subDataService.liquityDsrPaybackSubData.encode(targetRatio);
@@ -150,6 +156,12 @@ exports.aaveV2Encode = {
     leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
         return subDataService.aaveV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
     },
+    leverageManagementWithoutSubProxy(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.aaveV2LeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const triggerData = triggerService.aaveV2RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
 };
 exports.aaveV3Encode = {
     leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
@@ -216,11 +228,23 @@ exports.compoundV2Encode = {
     leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
         return subDataService.compoundV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
     },
+    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.compoundV2LeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const triggerData = triggerService.compoundV2RatioTrigger.encode(user, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
 };
 exports.compoundV3Encode = {
     leverageManagement(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA) {
         return subDataService.compoundV3LeverageManagementSubData.encode(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA);
     },
+    leverageManagementWithoutSubProxy(strategyOrBundleId, market, baseToken, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.compoundV3LeverageManagementSubDataWithoutSubProxy.encode(market, baseToken, targetRatio, ratioState);
+        const triggerData = triggerService.compoundV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
     leverageManagementOnPrice(strategyOrBundleId, market, collToken, baseToken, targetRatio, price, priceState, ratioState, // REPAY for repay on price, BOOST for boost on price
     user) {
         const isBundle = true;
@@ -257,6 +281,13 @@ exports.exchangeEncode = {
     limitOrder(fromToken, toToken, amount, targetPrice, goodUntil, orderType) {
         return subDataService.exchangeLimitOrderSubData.encode(fromToken, toToken, amount, targetPrice, goodUntil, orderType);
     },
+    limitOrderWithoutSubProxy(fromToken, toToken, amount, targetPrice, goodUntil, orderType, fromTokenDecimals, toTokenDecimals, network) {
+        (0, utils_1.requireAddresses)([fromToken, toToken]);
+        const subData = subDataService.exchangeLimitOrderSubDataWithoutSubProxy.encode(fromToken, toToken, amount);
+        const triggerData = triggerService.exchangeOffchainPriceTrigger.encode(targetPrice, Number(goodUntil), orderType, fromTokenDecimals, toTokenDecimals);
+        const strategyId = constants_1.STRATEGY_IDS[network].EXCHANGE_LIMIT_ORDER;
+        return [strategyId, false, triggerData, subData];
+    },
 };
 exports.sparkEncode = {
     leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
@@ -377,3 +408,32 @@ exports.fluidEncode = {
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
+exports.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 = enums_1.CloseToAssetType.DEBT, takeProfitPrice = '0', takeProfitType = enums_1.CloseToAssetType.COLLATERAL) {
+        const isBundle = true;
+        const closeType = (0, utils_1.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];
+    },
+};

package/cjs/services/strategySubService.test.js

@@ -1614,4 +1614,100 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
+    describe('When testing strategySubService.aaveV4Encode', () => {
+        describe('leverageManagement()', () => {
+            const examples = [
+                [
+                    [1, true, ["0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000010a741a4627800000000000000000000000000000000000000000000000000000000000000000001"], ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e", "0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x00000000000000000000000000000000000000000000000014d1120d7b160000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000"]],
+                    [
+                        1,
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        web3Utils.toChecksumAddress('0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e'),
+                        enums_1.RatioState.UNDER,
+                        150,
+                        120,
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    (0, chai_1.expect)(strategySubService_1.aaveV4Encode.leverageManagement(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('leverageManagementOnPrice()', () => {
+            const examples = [
+                [
+                    [2, true, ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000005150ae84a8cdf000000000000000000000000000000000000000000000000000000000000000000000"], ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e", "0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c", "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0x000000000000000000000000000000000000000000000000000000000000000a", "0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "0x0000000000000000000000000000000000000000000000000000000000000014", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x00000000000000000000000000000000000000000000000016345785d8a00000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000"]],
+                    [
+                        2,
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        web3Utils.toChecksumAddress('0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e'),
+                        web3Utils.toChecksumAddress('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'),
+                        10,
+                        web3Utils.toChecksumAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+                        20,
+                        160,
+                        '1500',
+                        enums_1.RatioState.OVER,
+                        enums_1.RatioState.OVER, // ratioState - UNDER for repay, OVER for boost
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    (0, chai_1.expect)(strategySubService_1.aaveV4Encode.leverageManagementOnPrice(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('closeOnPrice()', () => {
+            const examples = [
+                [
+                    [3, true, ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000004be4e7267b6ae000000000000000000000000000000000000000000000000000000000000000000000"], ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e", "0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c", "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0x000000000000000000000000000000000000000000000000000000000000000a", "0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "0x0000000000000000000000000000000000000000000000000000000000000014", "0x0000000000000000000000000000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000"]],
+                    [
+                        3,
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        web3Utils.toChecksumAddress('0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e'),
+                        web3Utils.toChecksumAddress('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'),
+                        10,
+                        web3Utils.toChecksumAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+                        20,
+                        '1400',
+                        enums_1.CloseToAssetType.DEBT,
+                        '0',
+                        enums_1.CloseToAssetType.COLLATERAL
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    (0, chai_1.expect)(strategySubService_1.aaveV4Encode.closeOnPrice(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('collateralSwitch()', () => {
+            const examples = [
+                [
+                    [4, false, ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000005150ae84a8cdf000000000000000000000000000000000000000000000000000000000000000000001"], ["0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e", "0x0000000000000000000000001031d218133afab8c2b819b1366c7e434ad91e9c", "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0x000000000000000000000000000000000000000000000000000000000000000a", "0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "0x0000000000000000000000000000000000000000000000000000000000000014", "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000"]],
+                    [
+                        4,
+                        web3Utils.toChecksumAddress('0x1031d218133AFaB8c2B819B1366c7E434Ad91E9c'),
+                        web3Utils.toChecksumAddress('0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e'),
+                        web3Utils.toChecksumAddress('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'),
+                        10,
+                        web3Utils.toChecksumAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+                        20,
+                        '1000000000000000000',
+                        '1500',
+                        enums_1.RatioState.UNDER,
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    (0, chai_1.expect)(strategySubService_1.aaveV4Encode.collateralSwitch(...actual)).to.eql(expected);
+                });
+            });
+        });
+    });
 });