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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.10",
+  "version": "3.3.11-aave-v4-1-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -23,7 +23,7 @@
   "repository": "https://github.com/defisaver/automation-sdk",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/sdk": "^1.3.15",
+    "@defisaver/sdk": "1.3.21-aave-v4-dev",
     "@defisaver/tokens": "^1.6.19",
     "@ethersproject/address": "^5.0.10",
     "@ethersproject/solidity": "^5.0.9",

package/src/automation/private/StrategiesAutomation.test.ts

@@ -659,5 +659,45 @@ 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)', () => {
+      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 = {
+        ...base,
+        subId: 1,
+        strategyData: { decoded: { triggerData: { spoke: spoke1 }, subData: {} } },
+        specific: { mergeId: 'boost', subId2: 1 },
+      };
+      const repaySpoke2 = {
+        ...base,
+        subId: 2,
+        strategyData: { decoded: { triggerData: { spoke: spoke2 }, subData: {} } },
+        specific: { mergeWithId: 'boost', subId1: 2 },
+      };
+      const boostSpoke2 = {
+        ...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: { subIds?: number[] }) => m.subIds?.length === 2);
+      const loneBoost = merged.find((m: { subIds?: number[] }) => m.subIds?.length === 1);
+      expect(mergedPair?.strategyData?.decoded?.triggerData?.spoke).to.equal(spoke2);
+      expect(loneBoost?.subId).to.equal(1);
+    });
   });
 });

package/src/automation/private/StrategiesAutomation.ts

@@ -129,9 +129,20 @@ export default class StrategiesAutomation extends Automation {
       && (
         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.protocol.id !== ProtocolIdentifiers.StrategiesAutomation.AaveV4
+        || this._aaveV4MergeSpokesMatch(s, current)
       );
   }
 
+  /** Repay/boost leverage pairs must not merge across different Aave V4 spokes. */
+  private _aaveV4MergeSpokesMatch(s: Position.Automated, current: Position.Automated): boolean {
+    const a = s.strategyData?.decoded?.triggerData?.spoke as EthereumAddress | undefined;
+    const b = current.strategyData?.decoded?.triggerData?.spoke as EthereumAddress | undefined;
+    return !!a && !!b && a.toLowerCase() === b.toLowerCase();
+  }
+
   protected mergeSubs(_subscriptions:(Position.Automated | null)[]) {
     const mergeBase = _subscriptions.filter(s => isDefined(s) && isDefined(s.specific.mergeWithId)) as Position.Automated[];
     const mergeExtension = _subscriptions.filter(s => isDefined(s) && isDefined(s.specific.mergeId)) as Position.Automated[];

package/src/constants/index.ts

@@ -23,6 +23,8 @@ import LegacyProtocol from '../automation/private/LegacyProtocol';
 // General
 export const ZERO_ADDRESS: EthereumAddress = '0x0000000000000000000000000000000000000000';
 
+export const EMPTY_SLOT: string = '0x0000000000000000000000000000000000000000000000000000000000000000';
+
 export const AAVE_V3_VARIABLE_BORROW_RATE = 2;
 
 export const PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.StrategiesAutomation, Interfaces.Protocol> = (() => {
@@ -123,6 +125,16 @@ export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
     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: OptimismStrategiesInfo = {
@@ -496,6 +508,66 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     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: OptimismBundleInfo = {

package/src/services/ethereumService.test.ts

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

package/src/services/strategiesService.ts

@@ -7,7 +7,9 @@ import type {
   Position, ParseData, StrategiesToProtocolVersionMapping, BundleOrStrategy, StrategyOrBundleIds,
   BundleInfoUnion, StrategyInfoUnion,
 } from '../types';
-import { ChainId, ProtocolIdentifiers, Strategies } from '../types/enums';
+import {
+  ChainId, ProtocolIdentifiers, RatioState, Strategies,
+} from '../types/enums';
 
 import {
   getPositionId, getRatioStateInfoForAaveCloseStrategy, getStopLossAndTakeProfitTypeByCloseStrategyType, isRatioStateOver, wethToEthByAddress,
@@ -383,6 +385,108 @@ function parseAaveV3CollateralSwitch(position: Position.Automated, parseData: Pa
   return _position;
 }
 
+function parseAaveV4LeverageManagement(position: Position.Automated, parseData: ParseData): Position.Automated {
+  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 as Strategies.Identifiers);
+
+  _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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
 
@@ -782,9 +886,37 @@ function parseSparkLeverageManagement(position: Position.Automated, parseData: P
   return _position;
 }
 
-function parseSparkCloseOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
+function parseSparkLeverageManagementOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
   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: Position.Automated, parseData: ParseData): Position.Automated {
+  const _position = cloneDeep(position);
   const { subStruct } = parseData.subscriptionEventData;
 
   const triggerData = triggerService.sparkQuotePriceRangeTrigger.decode(subStruct.triggerData);
@@ -1207,6 +1339,20 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
     [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,
@@ -1237,6 +1383,8 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
   [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]: {