@defisaver/automation-sdk 3.3.22-instant-twap-close-dev → 3.3.23

package/esm/types/enums.js

@@ -105,24 +105,32 @@ export var Strategies;
         MainnetIds[MainnetIds["AAVE_V4_COLLATERAL_SWITCH_EOA"] = 155] = "AAVE_V4_COLLATERAL_SWITCH_EOA";
         MainnetIds[MainnetIds["SPARK_COLLATERAL_SWITCH"] = 156] = "SPARK_COLLATERAL_SWITCH";
         MainnetIds[MainnetIds["SPARK_GENERIC_FL_COLLATERAL_SWITCH"] = 167] = "SPARK_GENERIC_FL_COLLATERAL_SWITCH";
+        MainnetIds[MainnetIds["AAVE_V3_DEBT_SWITCH"] = 168] = "AAVE_V3_DEBT_SWITCH";
+        MainnetIds[MainnetIds["AAVE_V3_DEBT_SWITCH_EOA"] = 169] = "AAVE_V3_DEBT_SWITCH_EOA";
     })(MainnetIds = Strategies.MainnetIds || (Strategies.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {
         OptimismIds[OptimismIds["EXCHANGE_DCA"] = 8] = "EXCHANGE_DCA";
         OptimismIds[OptimismIds["EXCHANGE_LIMIT_ORDER"] = 9] = "EXCHANGE_LIMIT_ORDER";
         OptimismIds[OptimismIds["AAVE_V3_COLLATERAL_SWITCH"] = 24] = "AAVE_V3_COLLATERAL_SWITCH";
+        OptimismIds[OptimismIds["AAVE_V3_DEBT_SWITCH"] = 25] = "AAVE_V3_DEBT_SWITCH";
+        OptimismIds[OptimismIds["AAVE_V3_DEBT_SWITCH_EOA"] = 26] = "AAVE_V3_DEBT_SWITCH_EOA";
     })(OptimismIds = Strategies.OptimismIds || (Strategies.OptimismIds = {}));
     let BaseIds;
     (function (BaseIds) {
         BaseIds[BaseIds["EXCHANGE_DCA"] = 8] = "EXCHANGE_DCA";
         BaseIds[BaseIds["EXCHANGE_LIMIT_ORDER"] = 9] = "EXCHANGE_LIMIT_ORDER";
         BaseIds[BaseIds["AAVE_V3_COLLATERAL_SWITCH"] = 56] = "AAVE_V3_COLLATERAL_SWITCH";
+        BaseIds[BaseIds["AAVE_V3_DEBT_SWITCH"] = 61] = "AAVE_V3_DEBT_SWITCH";
+        BaseIds[BaseIds["AAVE_V3_DEBT_SWITCH_EOA"] = 62] = "AAVE_V3_DEBT_SWITCH_EOA";
     })(BaseIds = Strategies.BaseIds || (Strategies.BaseIds = {}));
     let ArbitrumIds;
     (function (ArbitrumIds) {
         ArbitrumIds[ArbitrumIds["EXCHANGE_DCA"] = 8] = "EXCHANGE_DCA";
         ArbitrumIds[ArbitrumIds["EXCHANGE_LIMIT_ORDER"] = 9] = "EXCHANGE_LIMIT_ORDER";
         ArbitrumIds[ArbitrumIds["AAVE_V3_COLLATERAL_SWITCH"] = 50] = "AAVE_V3_COLLATERAL_SWITCH";
+        ArbitrumIds[ArbitrumIds["AAVE_V3_DEBT_SWITCH"] = 55] = "AAVE_V3_DEBT_SWITCH";
+        ArbitrumIds[ArbitrumIds["AAVE_V3_DEBT_SWITCH_EOA"] = 56] = "AAVE_V3_DEBT_SWITCH_EOA";
     })(ArbitrumIds = Strategies.ArbitrumIds || (Strategies.ArbitrumIds = {}));
     let Identifiers;
     (function (Identifiers) {
@@ -141,8 +149,6 @@ export var Strategies;
         Identifiers["CloseOnPriceToColl"] = "close-on-price-to-collateral";
         Identifiers["CloseOnPrice"] = "close-on-price";
         Identifiers["EoaCloseOnPrice"] = "eoa-close-on-price";
-        Identifiers["InstantCloseOnPrice"] = "instant-close-on-price";
-        Identifiers["EoaInstantCloseOnPrice"] = "eoa-instant-close-on-price";
         Identifiers["TrailingStopToColl"] = "trailing-stop-to-collateral";
         Identifiers["TrailingStopToDebt"] = "trailing-stop-to-debt";
         Identifiers["Rebond"] = "rebond";
@@ -159,6 +165,8 @@ export var Strategies;
         Identifiers["EoaRepayOnPrice"] = "eoa-repay-on-price";
         Identifiers["CollateralSwitch"] = "collateral-switch";
         Identifiers["EoaCollateralSwitch"] = "eoa-collateral-switch";
+        Identifiers["DebtSwitch"] = "debt-switch";
+        Identifiers["EoaDebtSwitch"] = "eoa-debt-switch";
         Identifiers["LiquidationProtection"] = "liquidation-protection";
         Identifiers["EoaLiquidationProtection"] = "liquidation-protection-eoa";
     })(Identifiers = Strategies.Identifiers || (Strategies.Identifiers = {}));
@@ -273,8 +281,6 @@ export var Bundles;
         MainnetIds[MainnetIds["SPARK_EOA_BOOST_ON_PRICE"] = 91] = "SPARK_EOA_BOOST_ON_PRICE";
         MainnetIds[MainnetIds["SPARK_EOA_CLOSE"] = 92] = "SPARK_EOA_CLOSE";
         MainnetIds[MainnetIds["SPARK_EOA_LIQUIDATION_PROTECTION"] = 93] = "SPARK_EOA_LIQUIDATION_PROTECTION";
-        MainnetIds[MainnetIds["AAVE_V3_SW_INSTANT_CLOSE"] = 94] = "AAVE_V3_SW_INSTANT_CLOSE";
-        MainnetIds[MainnetIds["AAVE_V3_EOA_INSTANT_CLOSE"] = 95] = "AAVE_V3_EOA_INSTANT_CLOSE";
     })(MainnetIds = Bundles.MainnetIds || (Bundles.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {
@@ -291,9 +297,6 @@ export var Bundles;
         OptimismIds[OptimismIds["AAVE_V3_EOA_CLOSE"] = 10] = "AAVE_V3_EOA_CLOSE";
         OptimismIds[OptimismIds["AAVE_V3_SW_LIQUIDATION_PROTECTION"] = 11] = "AAVE_V3_SW_LIQUIDATION_PROTECTION";
         OptimismIds[OptimismIds["AAVE_V3_EOA_LIQUIDATION_PROTECTION"] = 12] = "AAVE_V3_EOA_LIQUIDATION_PROTECTION";
-        // TODO -> Fix ids
-        OptimismIds[OptimismIds["AAVE_V3_SW_INSTANT_CLOSE"] = 13] = "AAVE_V3_SW_INSTANT_CLOSE";
-        OptimismIds[OptimismIds["AAVE_V3_EOA_INSTANT_CLOSE"] = 14] = "AAVE_V3_EOA_INSTANT_CLOSE";
     })(OptimismIds = Bundles.OptimismIds || (Bundles.OptimismIds = {}));
     let BaseIds;
     (function (BaseIds) {
@@ -337,8 +340,6 @@ export var Bundles;
         BaseIds[BaseIds["MORPHO_BLUE_EOA_REPAY_ON_PRICE"] = 40] = "MORPHO_BLUE_EOA_REPAY_ON_PRICE";
         BaseIds[BaseIds["MORPHO_BLUE_EOA_CLOSE"] = 41] = "MORPHO_BLUE_EOA_CLOSE";
         BaseIds[BaseIds["MORPHO_BLUE_EOA_LIQUIDATION_PROTECTION"] = 42] = "MORPHO_BLUE_EOA_LIQUIDATION_PROTECTION";
-        BaseIds[BaseIds["AAVE_V3_SW_INSTANT_CLOSE"] = 43] = "AAVE_V3_SW_INSTANT_CLOSE";
-        BaseIds[BaseIds["AAVE_V3_EOA_INSTANT_CLOSE"] = 44] = "AAVE_V3_EOA_INSTANT_CLOSE";
     })(BaseIds = Bundles.BaseIds || (Bundles.BaseIds = {}));
     let ArbitrumIds;
     (function (ArbitrumIds) {
@@ -382,7 +383,5 @@ export var Bundles;
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_EOA_BOOST_ON_PRICE"] = 37] = "MORPHO_BLUE_EOA_BOOST_ON_PRICE";
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_EOA_REPAY_ON_PRICE"] = 38] = "MORPHO_BLUE_EOA_REPAY_ON_PRICE";
         ArbitrumIds[ArbitrumIds["MORPHO_BLUE_EOA_CLOSE"] = 39] = "MORPHO_BLUE_EOA_CLOSE";
-        ArbitrumIds[ArbitrumIds["AAVE_V3_SW_INSTANT_CLOSE"] = 40] = "AAVE_V3_SW_INSTANT_CLOSE";
-        ArbitrumIds[ArbitrumIds["AAVE_V3_EOA_INSTANT_CLOSE"] = 41] = "AAVE_V3_EOA_INSTANT_CLOSE";
     })(ArbitrumIds = Bundles.ArbitrumIds || (Bundles.ArbitrumIds = {}));
 })(Bundles || (Bundles = {}));

package/esm/types/index.d.ts

@@ -1,7 +1,7 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
+import type { StrategyModel } from './contracts/generated/SubStorage';
 import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
@@ -53,6 +53,21 @@ interface _SubscriptionOptions {
     unexpiredOnly: boolean;
 }
 export type SubscriptionOptions = Partial<_SubscriptionOptions>;
+/** Subscription record as returned by the automation API (GET /v1/subscriptions) */
+export interface ApiSubscriptionRecord {
+    id: number;
+    wallet: EthereumAddress;
+    wallet_type: string;
+    is_enabled: boolean;
+    is_bundle: boolean;
+    strategy_or_bundle_id: number;
+    strategy_ids: number[];
+    sub_data_hash: string;
+    trigger_data: string[];
+    sub_data: string[];
+    block_number: number;
+    additional_triggers: string[] | null;
+}
 export declare namespace Interfaces {
     interface ProtocolBase {
         id: ProtocolIdentifiers.StrategiesAutomation | ProtocolIdentifiers.LegacyAutomation;
@@ -291,10 +306,17 @@ export interface BundlesInfo {
     [ChainId.Base]: BaseBundleInfo;
 }
 export type StrategyOrBundleIds = typeof Strategies.MainnetIds[keyof typeof Strategies.MainnetIds] | typeof Strategies.OptimismIds[keyof typeof Strategies.OptimismIds] | typeof Strategies.ArbitrumIds[keyof typeof Strategies.ArbitrumIds] | typeof Strategies.BaseIds[keyof typeof Strategies.BaseIds] | typeof Bundles.MainnetIds[keyof typeof Bundles.MainnetIds] | typeof Bundles.OptimismIds[keyof typeof Bundles.OptimismIds] | typeof Bundles.ArbitrumIds[keyof typeof Bundles.ArbitrumIds] | typeof Bundles.BaseIds[keyof typeof Bundles.BaseIds];
+/** Fields of the Subscribe event that parsing relies on */
+export interface SubscriptionEventData {
+    subId: string;
+    proxy: EthereumAddress;
+    subHash: string;
+    subStruct: StrategyModel.StrategySubStructOutputStruct;
+}
 export interface ParseData {
     chainId: ChainId;
     blockNumber: BlockNumber;
-    subscriptionEventData: Subscribe['returnValues'];
+    subscriptionEventData: SubscriptionEventData;
     strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct;
 }
 type MapToProtocolVersion<T> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.22-instant-twap-close-dev",
+  "version": "3.3.23",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

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

@@ -1,7 +1,8 @@
 import Web3 from 'web3';
 import { expect } from 'chai';
 
-import {ChainId} from '../../types/enums';
+import { ChainId } from '../../types/enums';
+import type { ApiSubscriptionRecord } from '../../types';
 
 import '../../configuration';
 import StrategiesAutomation from './StrategiesAutomation';
@@ -700,4 +701,67 @@ describe('Feature: StrategiesAutomation.ts', () => {
       expect(loneBoost?.subId).to.equal(1);
     });
   });
+
+  describe('When testing StrategiesAutomation.parseSubscriptionsFromApi', () => {
+    const strategiesAutomation = new StrategiesAutomation({
+      chainId: ChainId.Ethereum,
+      provider: Web3_1,
+      providerFork: null!,
+    });
+
+    const owner = '0x9cB7E19861665366011899d74E75d4F2A419aEeD';
+    const subData = [
+      '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    ];
+    // Aave V3 leverage management: repay (bundle 8, ratio under) and boost (bundle 9, ratio over) for the same owner and market
+    const repay: ApiSubscriptionRecord = {
+      id: 379,
+      wallet: owner,
+      wallet_type: 'safe',
+      is_enabled: true,
+      is_bundle: true,
+      strategy_or_bundle_id: 8,
+      strategy_ids: [34, 35],
+      sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001'],
+      sub_data: subData,
+      block_number: 18015756,
+      additional_triggers: null,
+    };
+    const boost: ApiSubscriptionRecord = {
+      ...repay,
+      id: 380,
+      is_enabled: false,
+      strategy_or_bundle_id: 9,
+      sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111',
+      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'],
+    };
+
+    it('Given API records should return parsed positions', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost]);
+      expect(positions).to.have.length(2);
+      expect(positions.map((p) => p?.subId)).to.eql([379, 380]);
+      expect(positions.map((p) => p?.isEnabled)).to.eql([true, false]);
+    });
+
+    it('Given mergeSubs option should merge the repay and boost pair', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { mergeSubs: true });
+      expect(positions).to.have.length(1);
+      expect(positions[0]?.subIds).to.eql([379, 380]);
+      expect(positions[0]?.isEnabled).to.equal(true);
+    });
+
+    it('Given enabledOnly option should drop disabled records before parsing', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { enabledOnly: true });
+      expect(positions.map((p) => p?.subId)).to.eql([379]);
+    });
+
+    it('Given a record of an unknown strategy should return null for it', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([{ ...repay, strategy_or_bundle_id: 9999 }]);
+      expect(positions).to.eql([null]);
+    });
+  });
 });

package/src/automation/private/StrategiesAutomation.ts

@@ -4,6 +4,7 @@ import type { PastEventOptions } from 'web3-eth-contract';
 import PromisePool from 'es6-promise-pool';
 import type {
   Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, PlaceholderType, BlockNumber,
+  ApiSubscriptionRecord,
 } from '../../types';
 import type {
   StrategyModel, Subscribe, SubStorage, UpdateData,
@@ -15,6 +16,7 @@ import { addToObjectIf, isDefined, isUndefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
 import { getEventsFromContract, multicall } from '../../services/ethereumService';
 import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
+import { parseDataFromApiSubscription } from '../../services/apiSubscriptionsService';
 
 import Automation from './Automation';
 
@@ -259,6 +261,21 @@ export default class StrategiesAutomation extends Automation {
     return this._getSubscriptions(undefined, options);
   }
 
+  /**
+   * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
+   */
+  public parseSubscriptionsFromApi(records: ApiSubscriptionRecord[], options?: SubscriptionOptions): (Position.Automated | null)[] {
+    const filtered = options?.enabledOnly ? records.filter((record) => record.is_enabled) : records;
+
+    let subscriptions = filtered.map((record) => this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId)));
+
+    if (options?.mergeSubs) {
+      subscriptions = this.mergeSubs(subscriptions);
+    }
+
+    return options?.unexpiredOnly ? this.removeExpiredSubscriptions(subscriptions) : subscriptions;
+  }
+
   public async getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]> {
     return this._getSubscriptions(addresses, options);
   }

package/src/constants/index.ts

@@ -145,6 +145,16 @@ export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
     strategyId: Strategies.Identifiers.EoaCollateralSwitch,
     protocol: PROTOCOLS.Spark,
   },
+  [Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH]: {
+    strategyOrBundleId: Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH,
+    strategyId: Strategies.Identifiers.DebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
+  [Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaDebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
 };
 
 export const OPTIMISM_STRATEGIES_INFO: OptimismStrategiesInfo = {
@@ -163,6 +173,16 @@ export const OPTIMISM_STRATEGIES_INFO: OptimismStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH]: {
+    strategyOrBundleId: Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH,
+    strategyId: Strategies.Identifiers.DebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
+  [Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaDebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
 };
 
 export const BASE_STRATEGIES_INFO: BaseStrategiesInfo = {
@@ -181,6 +201,16 @@ export const BASE_STRATEGIES_INFO: BaseStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.BaseIds.AAVE_V3_DEBT_SWITCH]: {
+    strategyOrBundleId: Strategies.BaseIds.AAVE_V3_DEBT_SWITCH,
+    strategyId: Strategies.Identifiers.DebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
+  [Strategies.BaseIds.AAVE_V3_DEBT_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.BaseIds.AAVE_V3_DEBT_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaDebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
 };
 
 export const ARBITRUM_STRATEGIES_INFO: ArbitrumStrategiesInfo = {
@@ -199,6 +229,16 @@ export const ARBITRUM_STRATEGIES_INFO: ArbitrumStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH]: {
+    strategyOrBundleId: Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH,
+    strategyId: Strategies.Identifiers.DebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
+  [Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaDebtSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
 };
 
 export const STRATEGIES_INFO: StrategiesInfo = {
@@ -684,16 +724,6 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.EoaLiquidationProtection,
     protocol: PROTOCOLS.Spark,
   },
-  [Bundles.MainnetIds.AAVE_V3_SW_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_SW_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.InstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
-  [Bundles.MainnetIds.AAVE_V3_EOA_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_EOA_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.EoaInstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
 };
 
 export const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo = {
@@ -762,16 +792,6 @@ export const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo = {
     strategyId: Strategies.Identifiers.EoaLiquidationProtection,
     protocol: PROTOCOLS.AaveV3,
   },
-  [Bundles.OptimismIds.AAVE_V3_SW_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.OptimismIds.AAVE_V3_SW_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.InstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
-  [Bundles.OptimismIds.AAVE_V3_EOA_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.OptimismIds.AAVE_V3_EOA_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.EoaInstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
 };
 
 export const BASE_BUNDLES_INFO: BaseBundleInfo = {
@@ -975,16 +995,6 @@ export const BASE_BUNDLES_INFO: BaseBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.MorphoBlue,
   },
-  [Bundles.BaseIds.AAVE_V3_SW_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.BaseIds.AAVE_V3_SW_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.InstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
-  [Bundles.BaseIds.AAVE_V3_EOA_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.BaseIds.AAVE_V3_EOA_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.EoaInstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
 };
 
 export const ARBITRUM_BUNDLES_INFO: ArbitrumBundleInfo = {
@@ -1189,16 +1199,6 @@ export const ARBITRUM_BUNDLES_INFO: ArbitrumBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.MorphoBlue,
   },
-  [Bundles.ArbitrumIds.AAVE_V3_SW_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.ArbitrumIds.AAVE_V3_SW_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.InstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
-  [Bundles.ArbitrumIds.AAVE_V3_EOA_INSTANT_CLOSE]: {
-    strategyOrBundleId: Bundles.ArbitrumIds.AAVE_V3_EOA_INSTANT_CLOSE,
-    strategyId: Strategies.Identifiers.EoaInstantCloseOnPrice,
-    protocol: PROTOCOLS.AaveV3,
-  },
 };
 
 export const BUNDLES_INFO: BundlesInfo = {

package/src/services/apiSubscriptionsService.test.ts

@@ -0,0 +1,73 @@
+import { expect } from 'chai';
+
+import type { ApiSubscriptionRecord, ParseData } from '../types';
+import { ChainId } from '../types/enums';
+
+import '../configuration';
+import { parseDataFromApiSubscription } from './apiSubscriptionsService';
+import { parseStrategiesAutomatedPosition } from './strategiesService';
+
+describe('Feature: apiSubscriptionsService.ts', () => {
+  describe('When testing apiSubscriptionsService.parseDataFromApiSubscription', () => {
+    // same subscription as in strategiesService.test.ts, in the shape the automation API returns it
+    const record: ApiSubscriptionRecord = {
+      id: 379,
+      wallet: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+      wallet_type: 'safe',
+      is_enabled: true,
+      is_bundle: true,
+      strategy_or_bundle_id: 8,
+      strategy_ids: [34, 35],
+      sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+      trigger_data: [
+        '0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
+      ],
+      sub_data: [
+        '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+      block_number: 18015756,
+      additional_triggers: null,
+    };
+
+    const fromEvents: ParseData = {
+      chainId: ChainId.Ethereum,
+      blockNumber: 18015756,
+      subscriptionEventData: {
+        subId: '379',
+        proxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+        subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+        subStruct: {
+          strategyOrBundleId: '8',
+          isBundle: true,
+          triggerData: [
+            '0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
+          ],
+          subData: record.sub_data,
+        },
+      },
+      strategiesSubsData: {
+        userProxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+        isEnabled: true,
+        strategySubHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+      },
+    };
+
+    it('Given an API record should return the same parse data as Subscribe event and SubStorage would', () => {
+      expect(parseDataFromApiSubscription(record, ChainId.Ethereum)).to.eql(fromEvents);
+    });
+
+    it('Given an API record the parsed position should match the one parsed from events', () => {
+      const fromApi = parseStrategiesAutomatedPosition(parseDataFromApiSubscription(record, ChainId.Ethereum));
+      expect(fromApi).to.not.equal(null);
+      expect(fromApi).to.eql(parseStrategiesAutomatedPosition(fromEvents));
+    });
+
+    it('Given a disabled record should keep it disabled', () => {
+      const parseData = parseDataFromApiSubscription({ ...record, is_enabled: false }, ChainId.Ethereum);
+      expect(parseData.strategiesSubsData.isEnabled).to.equal(false);
+    });
+  });
+});

package/src/services/apiSubscriptionsService.ts

@@ -0,0 +1,33 @@
+import type { ApiSubscriptionRecord, ParseData } from '../types';
+import type { ChainId } from '../types/enums';
+
+function addHexPrefix(value: string): string {
+  return value.startsWith('0x') ? value : `0x${value}`;
+}
+
+/**
+ * @description Maps a subscription record returned by the automation API to the data
+ * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
+ */
+export function parseDataFromApiSubscription(record: ApiSubscriptionRecord, chainId: ChainId): ParseData {
+  return {
+    chainId,
+    blockNumber: record.block_number,
+    subscriptionEventData: {
+      subId: record.id.toString(),
+      proxy: record.wallet,
+      subHash: record.sub_data_hash,
+      subStruct: {
+        strategyOrBundleId: record.strategy_or_bundle_id.toString(),
+        isBundle: record.is_bundle,
+        triggerData: record.trigger_data.map(addHexPrefix),
+        subData: record.sub_data.map(addHexPrefix),
+      },
+    },
+    strategiesSubsData: {
+      userProxy: record.wallet,
+      isEnabled: record.is_enabled,
+      strategySubHash: record.sub_data_hash,
+    },
+  };
+}

package/src/services/strategiesService.test.ts

@@ -1,13 +1,10 @@
 import { expect } from 'chai';
 
-import {
-  Bundles, CloseStrategyType, CloseToAssetType, ProtocolIdentifiers, Strategies,
-} from '../types/enums';
+import { ProtocolIdentifiers, Strategies } from '../types/enums';
 import type { ParseData, Position } from '../types';
 
 import '../configuration';
 import { parseStrategiesAutomatedPosition } from './strategiesService';
-import { aaveV3Encode } from './strategySubService';
 
 describe('Feature: strategiesService.ts', () => {
   describe('When testing strategiesService.parseStrategiesAutomatedPosition', async () => {
@@ -79,7 +76,6 @@ describe('Feature: strategiesService.ts', () => {
             subId: '379',
             proxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
             subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            // @ts-ignore
             subStruct:
               {
                 strategyOrBundleId: '8',
@@ -106,78 +102,4 @@ describe('Feature: strategiesService.ts', () => {
       });
     });
   });
-
-  describe('When parsing Aave V3 instant close bundles', () => {
-    const owner = '0x1234567890123456789012345678901234567890';
-    const market = '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e';
-    const weth = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
-    const usdc = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
-
-    const bundles: Array<[string, Bundles.MainnetIds, Strategies.Identifiers]> = [
-      ['SW', Bundles.MainnetIds.AAVE_V3_SW_INSTANT_CLOSE, Strategies.Identifiers.InstantCloseOnPrice],
-      ['EOA', Bundles.MainnetIds.AAVE_V3_EOA_INSTANT_CLOSE, Strategies.Identifiers.EoaInstantCloseOnPrice],
-    ];
-
-    bundles.forEach(([walletType, expectedBundleId, expectedStrategyId]) => {
-      describe(`${walletType} bundle`, () => {
-        const [bundleId, isBundle, triggerData, subData] = aaveV3Encode.instantCloseOnPriceGeneric(
-          expectedBundleId,
-          weth, 0, usdc, 1, market, owner,
-          '1000000000000000000', '10000000000000000',
-          1500, CloseToAssetType.DEBT, 5000, CloseToAssetType.COLLATERAL,
-        );
-
-        const parseData = {
-          chainId: 1,
-          blockNumber: 1,
-          subscriptionEventData: {
-            subId: '1',
-            proxy: owner,
-            subHash: '0xhash',
-            subStruct: {
-              strategyOrBundleId: String(bundleId), isBundle, triggerData, subData,
-            },
-          },
-          strategiesSubsData: { userProxy: owner, isEnabled: true, strategySubHash: '0xhash' },
-        } as unknown as ParseData;
-
-        const result = parseStrategiesAutomatedPosition(parseData) as Position.Automated;
-
-        it('should identify the strategy as instant close on price', () => {
-          expect(result.strategy.strategyOrBundleId).to.equal(expectedBundleId);
-          expect(result.strategy.strategyId).to.equal(expectedStrategyId);
-          expect(result.protocol.id).to.equal(ProtocolIdentifiers.StrategiesAutomation.AaveV3);
-        });
-
-        it('should decode sub data including tsi and slippage', () => {
-          expect(result.strategyData.decoded.subData).to.eql({
-            collAsset: weth,
-            collAssetId: 0,
-            debtAsset: usdc,
-            debtAssetId: 1,
-            closeType: CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL_AND_STOP_LOSS_IN_DEBT,
-            marketAddr: market,
-            owner,
-            tsi: '1000000000000000000',
-            slippage: '10000000000000000',
-          });
-        });
-
-        it('should fill specific with prices and close types', () => {
-          expect(result.specific).to.eql({
-            collAsset: weth,
-            collAssetId: 0,
-            debtAsset: usdc,
-            debtAssetId: 1,
-            baseToken: weth,
-            quoteToken: usdc,
-            stopLossPrice: '1500',
-            takeProfitPrice: '5000',
-            stopLossType: CloseToAssetType.DEBT,
-            takeProfitType: CloseToAssetType.COLLATERAL,
-          });
-        });
-      });
-    });
-  });
 });

package/src/services/strategiesService.ts

@@ -433,42 +433,23 @@ function parseAaveV3CloseOnPrice(position: Position.Automated, parseData: ParseD
   return _position;
 }
 
-function parseAaveV3InstantCloseOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
+function parseAaveV3CollateralSwitch(position: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
-
   const { subStruct } = parseData.subscriptionEventData;
-
-  const triggerData = triggerService.aaveV3QuotePriceRangeTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.aaveV3InstantCloseGenericSubData.decode(subStruct.subData);
-
-  const { takeProfitType, stopLossType } = getStopLossAndTakeProfitTypeByCloseStrategyType(+subData.closeType);
-
-  _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, AAVE_V3_MARKET_ADDRESSES[_position.chainId]);
-
+  const triggerData = triggerService.aaveV3QuotePriceTrigger.decode(subStruct.triggerData);
+  const subData = subDataService.aaveV3CollateralSwitchSubData.decode(subStruct.subData);
   _position.strategyData.decoded.triggerData = triggerData;
   _position.strategyData.decoded.subData = subData;
-
-  _position.specific = {
-    collAsset: subData.collAsset,
-    collAssetId: subData.collAssetId,
-    debtAsset: subData.debtAsset,
-    debtAssetId: subData.debtAssetId,
-    baseToken: triggerData.collToken,
-    quoteToken: triggerData.debtToken,
-    stopLossPrice: triggerData.lowerPrice,
-    takeProfitPrice: triggerData.upperPrice,
-    stopLossType,
-    takeProfitType,
-  };
+  _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
 
   return _position;
 }
 
-function parseAaveV3CollateralSwitch(position: Position.Automated, parseData: ParseData): Position.Automated {
+function parseAaveV3DebtSwitch(position: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
   const { subStruct } = parseData.subscriptionEventData;
   const triggerData = triggerService.aaveV3QuotePriceTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.aaveV3CollateralSwitchSubData.decode(subStruct.subData);
+  const subData = subDataService.aaveV3DebtSwitchSubData.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);
@@ -1627,9 +1608,9 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
     [Strategies.Identifiers.EoaRepayOnPrice]: parseAaveV3LeverageManagementOnPrice,
     [Strategies.Identifiers.EoaBoostOnPrice]: parseAaveV3LeverageManagementOnPrice,
     [Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV3CloseOnPrice,
-    [Strategies.Identifiers.InstantCloseOnPrice]: parseAaveV3InstantCloseOnPrice,
-    [Strategies.Identifiers.EoaInstantCloseOnPrice]: parseAaveV3InstantCloseOnPrice,
     [Strategies.Identifiers.CollateralSwitch]: parseAaveV3CollateralSwitch,
+    [Strategies.Identifiers.DebtSwitch]: parseAaveV3DebtSwitch,
+    [Strategies.Identifiers.EoaDebtSwitch]: parseAaveV3DebtSwitch,
     [Strategies.Identifiers.LiquidationProtection]: parseAaveV3LiquidationProtection,
     [Strategies.Identifiers.EoaLiquidationProtection]: parseAaveV3LiquidationProtection,
   },