@defisaver/automation-sdk 3.3.18 → 3.3.19-sub-fetching.1-dev

package/esm/types/index.d.ts

@@ -1,8 +1,8 @@
 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 { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
+import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType, SubscriptionStatus } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
 export type BlockNumber = BlockType;
@@ -53,6 +53,23 @@ 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;
+    invalid: boolean;
+    status: SubscriptionStatus;
+    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;
@@ -105,6 +122,9 @@ export declare namespace Position {
             triggerBoostRatio?: number;
             targetBoostRatio?: number;
             boostEnabled?: boolean;
+            /** Set only for subscriptions parsed from the automation API: the backend marked that half invalid */
+            repayInvalid?: boolean;
+            boostInvalid?: boolean;
         }
         interface CloseOnPrice extends Base {
             price: string;
@@ -238,6 +258,8 @@ export declare namespace Position {
         subId: number;
         subIds?: number[];
         isEnabled?: boolean;
+        /** Set only for subscriptions parsed from the automation API: the backend will not execute this subscription */
+        invalid?: boolean;
         subHash: string;
         blockNumber: BlockNumber;
         protocol: Interfaces.Protocol;
@@ -291,10 +313,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.18",
+  "version": "3.3.19-sub-fetching.1-dev",
   "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, SubscriptionStatus } from '../../types/enums';
+import type { ApiSubscriptionRecord } from '../../types';
 
 import '../../configuration';
 import StrategiesAutomation from './StrategiesAutomation';
@@ -700,4 +701,86 @@ 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,
+      invalid: false,
+      status: SubscriptionStatus.Active,
+      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,
+      status: SubscriptionStatus.Disabled,
+      strategy_or_bundle_id: 9,
+      sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111',
+      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'],
+    };
+
+    it('Given API records should return parsed positions carrying the invalid flags', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, { ...boost, invalid: true }]);
+      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]);
+      expect(positions.map((p) => p?.invalid)).to.eql([false, true]);
+      expect((positions[0]?.specific as { repayInvalid?: boolean }).repayInvalid).to.equal(false);
+      expect((positions[1]?.specific as { boostInvalid?: boolean }).boostInvalid).to.equal(true);
+    });
+
+    it('Given a merged pair should keep each half\'s invalid flag and mark the pair invalid only when both are', () => {
+      const oneInvalid = strategiesAutomation.parseSubscriptionsFromApi([repay, { ...boost, invalid: true }], { mergeSubs: true });
+      expect(oneInvalid).to.have.length(1);
+      expect(oneInvalid[0]?.invalid).to.equal(false);
+      expect(oneInvalid[0]?.specific).to.include({ repayInvalid: false, boostInvalid: true });
+
+      const bothInvalid = strategiesAutomation.parseSubscriptionsFromApi(
+        [{ ...repay, invalid: true }, { ...boost, invalid: true }],
+        { mergeSubs: true },
+      );
+      expect(bothInvalid[0]?.invalid).to.equal(true);
+    });
+
+    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';
 
@@ -23,6 +25,17 @@ interface IStrategiesAutomation extends Interfaces.Automation {
   providerFork?: Web3,
 }
 
+/**
+ * Adds the backend flags to a parsed position. A repay or boost half of a leverage management pair also gets its
+ * own invalid flag in specific, next to repayEnabled and boostEnabled, so it survives merging.
+ */
+const withApiFlags = (position: Position.Automated, record: ApiSubscriptionRecord): Position.Automated => {
+  const specific = { ...position.specific } as Position.Specific.RatioProtection;
+  if (isDefined(specific.mergeWithId)) specific.repayInvalid = record.invalid;
+  if (isDefined(specific.mergeId)) specific.boostInvalid = record.invalid;
+  return { ...position, invalid: record.invalid, specific: specific as Position.SpecificAny };
+};
+
 export default class StrategiesAutomation extends Automation {
   protected chainId: ChainId;
 
@@ -167,6 +180,8 @@ export default class StrategiesAutomation extends Automation {
           blockNumber: Dec.max(mergePair.blockNumber, current.blockNumber).toNumber(),
           subIds: [current.subId, mergePair.subId],
           isEnabled: mergePair.isEnabled || current.isEnabled,
+          // set only for subscriptions parsed from the automation API, per half flags live in specific
+          ...addToObjectIf(isDefined(current.invalid), { invalid: !!mergePair.invalid && !!current.invalid }),
           specific: {
             ...mergePair.specific,
             ...current.specific,
@@ -259,6 +274,24 @@ 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: (Position.Automated | null)[] = filtered.map((record) => {
+      const position = this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId));
+      return position && withApiFlags(position, record);
+    });
+
+    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

@@ -140,6 +140,11 @@ export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.Spark,
   },
+  [Strategies.MainnetIds.SPARK_GENERIC_FL_COLLATERAL_SWITCH]: {
+    strategyOrBundleId: Strategies.MainnetIds.SPARK_GENERIC_FL_COLLATERAL_SWITCH,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.Spark,
+  },
 };
 
 export const OPTIMISM_STRATEGIES_INFO: OptimismStrategiesInfo = {
@@ -573,6 +578,31 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.AaveV4,
   },
+  [Bundles.MainnetIds.SPARK_EOA_REPAY]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_REPAY,
+    strategyId: Strategies.Identifiers.EoaRepay,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.SPARK_EOA_BOOST]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_BOOST,
+    strategyId: Strategies.Identifiers.EoaBoost,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.SPARK_EOA_CLOSE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_CLOSE,
+    strategyId: Strategies.Identifiers.EoaCloseOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.SPARK_EOA_REPAY_ON_PRICE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_REPAY_ON_PRICE,
+    strategyId: Strategies.Identifiers.EoaRepayOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.SPARK_EOA_BOOST_ON_PRICE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_BOOST_ON_PRICE,
+    strategyId: Strategies.Identifiers.EoaBoostOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
   [Bundles.MainnetIds.MAKER_SW_LIQUIDATION_PROTECTION]: {
     strategyOrBundleId: Bundles.MainnetIds.MAKER_SW_LIQUIDATION_PROTECTION,
     strategyId: Strategies.Identifiers.LiquidationProtection,
@@ -649,6 +679,11 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.EoaCloseOnPrice,
     protocol: PROTOCOLS.MorphoBlue,
   },
+  [Bundles.MainnetIds.SPARK_EOA_LIQUIDATION_PROTECTION]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_EOA_LIQUIDATION_PROTECTION,
+    strategyId: Strategies.Identifiers.EoaLiquidationProtection,
+    protocol: PROTOCOLS.Spark,
+  },
 };
 
 export const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo = {

package/src/services/apiSubscriptionsService.test.ts

@@ -0,0 +1,75 @@
+import { expect } from 'chai';
+
+import type { ApiSubscriptionRecord, ParseData } from '../types';
+import { ChainId, SubscriptionStatus } 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,
+      invalid: false,
+      status: SubscriptionStatus.Active,
+      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/ethereumService.test.ts

@@ -1,10 +1,11 @@
 import Web3 from 'web3';
 import { expect } from 'chai';
+import { omit } from 'lodash';
 import { getAssetInfo } from '@defisaver/tokens';
 import { PastEventOptions } from 'web3-eth-contract';
 
 import { ChainId } from '../types/enums';
-import type { BlockNumber, Multicall } from '../types';
+import type { BlockNumber, Multicall, PlaceholderType } from '../types';
 import { Contract } from '../types';
 import type { Erc20 } from '../types/contracts/generated';
 
@@ -115,7 +116,6 @@ describe('Feature: ethereumService.ts', () => {
             'address': '0x5f98805A4E8be255a32880FDeC7F6728C6568bA0',
             'blockHash': '0xb92cab2569456dbfbdb853d2c67d72c9a7580543dbcb55d483a77322b40755a4',
             'blockNumber': 15166163,
-            'blockTimestamp': '0x62d53ad8',
             'event': 'Transfer',
             'id': 'log_e2258e3a',
             'logIndex': 385,
@@ -142,7 +142,7 @@ describe('Feature: ethereumService.ts', () => {
           },
         ],
         [
-          makeErc20Contract(Web3_1, getAssetInfo('LUSD').address, ChainId.Ethereum),
+          { ...makeErc20Contract(Web3_1, getAssetInfo('LUSD').address, ChainId.Ethereum), createdBlock: 15166163 },
           null,
           'Transfer',
           {
@@ -161,7 +161,6 @@ describe('Feature: ethereumService.ts', () => {
             'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
             'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
             'blockNumber': 5353002,
-            'blockTimestamp': '0x624c1a5b',
             'event': 'Transfer',
             'id': 'log_f49645b8',
             'logIndex': 1,
@@ -207,7 +206,6 @@ describe('Feature: ethereumService.ts', () => {
             'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
             'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
             'blockNumber': 5353002,
-            'blockTimestamp': '0x624c1a5b',
             'event': 'Transfer',
             'id': 'log_f49645b8',
             'logIndex': 1,
@@ -251,9 +249,8 @@ describe('Feature: ethereumService.ts', () => {
 
     examples.forEach(([expected, actual]) => {
       it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, async () => {
-        const data = await getEventsFromContract(...actual);
-        console.log(data);
-        expect(await getEventsFromContract(...actual)).to.eql(expected);
+        const events = await getEventsFromContract(...actual);
+        expect(events.map((event: PlaceholderType) => omit(event, 'blockTimestamp'))).to.eql(expected);
       });
     });
   });

package/src/services/strategiesService.test.ts

@@ -76,7 +76,6 @@ describe('Feature: strategiesService.ts', () => {
             subId: '379',
             proxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
             subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            // @ts-ignore
             subStruct:
               {
                 strategyOrBundleId: '8',

package/src/services/strategiesService.ts

@@ -8,7 +8,7 @@ import type {
   BundleInfoUnion, StrategyInfoUnion,
 } from '../types';
 import {
-  ChainId, ProtocolIdentifiers, RatioState, Strategies,
+  ChainId, ProtocolIdentifiers, Strategies,
 } from '../types/enums';
 
 import {
@@ -448,11 +448,17 @@ function parseAaveV3CollateralSwitch(position: Position.Automated, parseData: Pa
 function parseSparkCollateralSwitch(position: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
   const { subStruct } = parseData.subscriptionEventData;
+  const isEOA = _position.strategy.strategyId.includes('eoa');
   const triggerData = triggerService.sparkQuotePriceTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.sparkCollateralSwitchSubData.decode(subStruct.subData);
+  const subData = isEOA
+    ? subDataService.sparkGenericFLCollateralSwitchSubData.decode(subStruct.subData)
+    : subDataService.sparkCollateralSwitchSubData.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.strategy.strategyId = isEOA
+    ? Strategies.Identifiers.EoaCollateralSwitch
+    : Strategies.Identifiers.CollateralSwitch;
   return _position;
 }
 
@@ -987,16 +993,19 @@ function parseSparkLeverageManagement(position: Position.Automated, parseData: P
 
   const { subStruct, subId, subHash } = parseData.subscriptionEventData;
   const { isEnabled } = parseData.strategiesSubsData;
+  const isEOA = _position.strategy.strategyId.includes('eoa');
 
   const triggerData = triggerService.sparkRatioTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.legacySparkLeverageManagementSubData.decode(subStruct.subData);
+  const subData = isEOA
+    ? subDataService.sparkGenericLeverageManagementSubData.decode(subStruct.subData)
+    : subDataService.legacySparkLeverageManagementSubData.decode(subStruct.subData);
 
   _position.strategyData.decoded.triggerData = triggerData;
   _position.strategyData.decoded.subData = subData;
 
   _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, triggerData.market);
 
-  const isRepay = _position.strategy.strategyId === Strategies.Identifiers.Repay;
+  const isRepay = [Strategies.Identifiers.Repay, Strategies.Identifiers.EoaRepay].includes(_position.strategy.strategyId as Strategies.Identifiers);
 
   if (isRepay) {
     _position.specific = {
@@ -1004,7 +1013,7 @@ function parseSparkLeverageManagement(position: Position.Automated, parseData: P
       targetRepayRatio: subData.targetRatio,
       repayEnabled: isEnabled,
       subId1: Number(subId),
-      mergeWithId: Strategies.Identifiers.Boost,
+      mergeWithId: isEOA ? Strategies.Identifiers.EoaBoost : Strategies.Identifiers.Boost,
       subHashRepay: subHash,
     };
   } else {
@@ -1013,12 +1022,14 @@ function parseSparkLeverageManagement(position: Position.Automated, parseData: P
       targetBoostRatio: subData.targetRatio,
       boostEnabled: isEnabled,
       subId2: Number(subId),
-      mergeId: Strategies.Identifiers.Boost,
+      mergeId: isEOA ? Strategies.Identifiers.EoaBoost : Strategies.Identifiers.Boost,
       subHashBoost: subHash,
     };
   }
 
-  _position.strategy.strategyId = Strategies.IdOverrides.LeverageManagement;
+  _position.strategy.strategyId = isEOA
+    ? Strategies.IdOverrides.EoaLeverageManagement
+    : Strategies.IdOverrides.LeverageManagement;
 
   return _position;
 }
@@ -1028,9 +1039,12 @@ function parseSparkLiquidationProtection(position: Position.Automated, parseData
 
   const { subStruct, subId, subHash } = parseData.subscriptionEventData;
   const { isEnabled } = parseData.strategiesSubsData;
+  const isEOA = _position.strategy.strategyId.includes('eoa');
 
   const triggerData = triggerService.sparkRatioTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.sparkLiquidationProtectionSubData.decode(subStruct.subData);
+  const subData = isEOA
+    ? subDataService.sparkGenericLiquidationProtectionSubData.decode(subStruct.subData)
+    : subDataService.sparkLiquidationProtectionSubData.decode(subStruct.subData);
 
   _position.strategyData.decoded.triggerData = triggerData;
   _position.strategyData.decoded.subData = subData;
@@ -1045,7 +1059,9 @@ function parseSparkLiquidationProtection(position: Position.Automated, parseData
     subHashRepay: subHash,
   };
 
-  _position.strategy.strategyId = Strategies.IdOverrides.LiquidationProtection;
+  _position.strategy.strategyId = isEOA
+    ? Strategies.IdOverrides.EoaLiquidationProtection
+    : Strategies.IdOverrides.LiquidationProtection;
 
   return _position;
 }
@@ -1054,9 +1070,12 @@ function parseSparkLiquidationProtection(position: Position.Automated, parseData
 function parseSparkLeverageManagementOnPrice(position: Position.Automated, parseData: ParseData): Position.Automated {
   const _position = cloneDeep(position);
   const { subStruct } = parseData.subscriptionEventData;
+  const isEOA = _position.strategy.strategyId.includes('eoa');
 
   const triggerData = triggerService.sparkQuotePriceTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.sparkLeverageManagementOnPriceSubData.decode(subStruct.subData);
+  const subData = isEOA
+    ? subDataService.sparkLeverageManagementOnPriceGenericSubData.decode(subStruct.subData)
+    : subDataService.sparkLeverageManagementOnPriceSubData.decode(subStruct.subData);
 
   _position.strategyData.decoded.triggerData = triggerData;
   _position.strategyData.decoded.subData = subData;
@@ -1077,6 +1096,10 @@ function parseSparkLeverageManagementOnPrice(position: Position.Automated, parse
     ratioState: triggerData.ratioState,
   };
 
+  _position.strategy.strategyId = isEOA
+    ? Strategies.IdOverrides.EoaLeverageManagementOnPrice
+    : Strategies.IdOverrides.LeverageManagementOnPrice;
+
   return _position;
 }
 
@@ -1087,10 +1110,13 @@ function parseSparkCloseOnPrice(position: Position.Automated, parseData: ParseDa
   const triggerData = triggerService.sparkQuotePriceRangeTrigger.decode(subStruct.triggerData);
   const subData = subDataService.sparkCloseGenericSubData.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, subData.marketAddr);
+  _position.strategy.strategyId = isEOA ? Strategies.Identifiers.EoaCloseOnPrice : Strategies.Identifiers.CloseOnPrice;
 
   const { takeProfitType, stopLossType } = getStopLossAndTakeProfitTypeByCloseStrategyType(+subData.closeType);
 
@@ -1625,8 +1651,15 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
     [Strategies.Identifiers.RepayOnPrice]: parseSparkLeverageManagementOnPrice,
     [Strategies.Identifiers.BoostOnPrice]: parseSparkLeverageManagementOnPrice,
     [Strategies.Identifiers.CloseOnPrice]: parseSparkCloseOnPrice,
+    [Strategies.Identifiers.EoaRepay]: parseSparkLeverageManagement,
+    [Strategies.Identifiers.EoaBoost]: parseSparkLeverageManagement,
+    [Strategies.Identifiers.EoaRepayOnPrice]: parseSparkLeverageManagementOnPrice,
+    [Strategies.Identifiers.EoaBoostOnPrice]: parseSparkLeverageManagementOnPrice,
+    [Strategies.Identifiers.EoaCloseOnPrice]: parseSparkCloseOnPrice,
     [Strategies.Identifiers.CollateralSwitch]: parseSparkCollateralSwitch,
+    [Strategies.Identifiers.EoaCollateralSwitch]: parseSparkCollateralSwitch,
     [Strategies.Identifiers.LiquidationProtection]: parseSparkLiquidationProtection,
+    [Strategies.Identifiers.EoaLiquidationProtection]: parseSparkLiquidationProtection,
   },
   [ProtocolIdentifiers.StrategiesAutomation.CrvUSD]: {
     [Strategies.Identifiers.Repay]: parseCrvUSDLeverageManagement,