@defisaver/automation-sdk 3.3.21-debt-switch-dev-dev → 3.3.22-coll-switch-generic-dev

package/esm/services/strategySubService.js

@@ -170,6 +170,12 @@ export const aaveV3Encode = {
         const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
         return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
     },
+    collateralSwitchGeneric(strategyOrBundleId, fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user, baseTokenAddress, quoteTokenAddress, price, state) {
+        const isBundle = false;
+        const subDataEncoded = subDataService.aaveV3GenericFLCollateralSwitchSubData.encode(fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user);
+        const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
+        return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+    },
     debtSwitch(strategyOrBundleId, fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user, baseTokenAddress, quoteTokenAddress, price, state) {
         const isBundle = false;
         const subDataEncoded = subDataService.aaveV3DebtSwitchSubData.encode(fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user);

package/esm/services/strategySubService.test.js

@@ -831,6 +831,42 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
+        describe('collateralSwitchGeneric()', () => {
+            const strategyId = 12345;
+            const fromAsset = web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address);
+            const toAsset = web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address);
+            const marketAddr = web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39');
+            const user = web3Utils.toChecksumAddress('0x1234567890abcdef1234567890abcdef12345678');
+            const examples = [
+                [
+                    RatioState.UNDER,
+                    '10000000000000000000',
+                    '0x0000000000000000000000000000000000000000000000008ac7230489e80000',
+                    '0000000000000000000000000000000000000000000000000000000000000001',
+                ],
+                [
+                    RatioState.OVER,
+                    MAXUINT,
+                    '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+                    '0000000000000000000000000000000000000000000000000000000000000000',
+                ],
+            ];
+            examples.forEach(([state, amountToSwitch, encodedAmount, encodedState]) => {
+                it(`encodes a generic collateral switch with the supplied quote pair and state ${state}`, () => {
+                    const expectedTrigger = `0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000000000003e8${encodedState}`;
+                    const expectedSubData = [
+                        '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                        '0x0000000000000000000000000000000000000000000000000000000000000100',
+                        '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        '0x000000000000000000000000000000000000000000000000000000000000ffff',
+                        '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+                        encodedAmount,
+                        '0x0000000000000000000000001234567890abcdef1234567890abcdef12345678',
+                    ];
+                    expect(aaveV3Encode.collateralSwitchGeneric(strategyId, fromAsset, 256, toAsset, 65535, marketAddr, amountToSwitch, user, toAsset, fromAsset, 0.00001, state)).to.eql([strategyId, false, [expectedTrigger], expectedSubData]);
+                });
+            });
+        });
         describe('debtSwitch()', () => {
             const examples = [
                 // USDC -> DAI, price 100000, state UNDER

package/esm/services/subDataService.d.ts

@@ -259,6 +259,18 @@ export declare const aaveV3CollateralSwitchSubData: {
         amountToSwitch: string;
     };
 };
+export declare const aaveV3GenericFLCollateralSwitchSubData: {
+    encode(fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, user: EthereumAddress): string[];
+    decode(subData: string[]): {
+        fromAsset: EthereumAddress;
+        fromAssetId: number;
+        toAsset: EthereumAddress;
+        toAssetId: number;
+        marketAddr: EthereumAddress;
+        amountToSwitch: string;
+        user: EthereumAddress;
+    };
+};
 export declare const aaveV3DebtSwitchSubData: {
     encode(fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, user: EthereumAddress): string[];
     decode(subData: string[]): {

package/esm/services/subDataService.js

@@ -542,6 +542,38 @@ export const aaveV3CollateralSwitchSubData = {
         };
     },
 };
+export const aaveV3GenericFLCollateralSwitchSubData = {
+    encode(fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user) {
+        const encodedFromAsset = AbiCoder.encodeParameter('address', fromAsset);
+        const encodedFromAssetId = AbiCoder.encodeParameter('uint16', fromAssetId);
+        const encodedToAsset = AbiCoder.encodeParameter('address', toAsset);
+        const encodedToAssetId = AbiCoder.encodeParameter('uint16', toAssetId);
+        const encodedMarketAddr = AbiCoder.encodeParameter('address', marketAddr);
+        const encodedAmountToSwitch = AbiCoder.encodeParameter('uint256', amountToSwitch);
+        const encodedUser = AbiCoder.encodeParameter('address', user);
+        return [
+            encodedFromAsset,
+            encodedFromAssetId,
+            encodedToAsset,
+            encodedToAssetId,
+            encodedMarketAddr,
+            encodedAmountToSwitch,
+            encodedUser,
+        ];
+    },
+    decode(subData) {
+        const fromAsset = AbiCoder.decodeParameter('address', subData[0]);
+        const fromAssetId = Number(AbiCoder.decodeParameter('uint16', subData[1]));
+        const toAsset = AbiCoder.decodeParameter('address', subData[2]);
+        const toAssetId = Number(AbiCoder.decodeParameter('uint16', subData[3]));
+        const marketAddr = AbiCoder.decodeParameter('address', subData[4]);
+        const amountToSwitch = AbiCoder.decodeParameter('uint256', subData[5]);
+        const user = AbiCoder.decodeParameter('address', subData[6]);
+        return {
+            fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user,
+        };
+    },
+};
 export const aaveV3DebtSwitchSubData = {
     encode(fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user) {
         const encodedFromAsset = AbiCoder.encodeParameter('address', fromAsset);

package/esm/services/subDataService.test.js

@@ -614,6 +614,41 @@ describe('Feature: subDataService.ts', () => {
             });
         });
     });
+    describe('When testing subDataService.aaveV3GenericFLCollateralSwitchSubData', () => {
+        const fromAsset = web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address);
+        const toAsset = web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address);
+        const marketAddr = web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39');
+        const user = web3Utils.toChecksumAddress('0x1234567890abcdef1234567890abcdef12345678');
+        const examples = [
+            ['10000000000000000000', '0x0000000000000000000000000000000000000000000000008ac7230489e80000'],
+            [MAXUINT, '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'],
+        ];
+        examples.forEach(([amountToSwitch, encodedAmount]) => {
+            const subData = [
+                '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                '0x0000000000000000000000000000000000000000000000000000000000000100',
+                '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                '0x000000000000000000000000000000000000000000000000000000000000ffff',
+                '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+                encodedAmount,
+                '0x0000000000000000000000001234567890abcdef1234567890abcdef12345678',
+            ];
+            it(`encode() preserves uint16 asset IDs and user when switching ${amountToSwitch}`, () => {
+                expect(subDataService.aaveV3GenericFLCollateralSwitchSubData.encode(fromAsset, 256, toAsset, 65535, marketAddr, amountToSwitch, user)).to.eql(subData);
+            });
+            it(`decode() preserves uint16 asset IDs and user when switching ${amountToSwitch}`, () => {
+                expect(subDataService.aaveV3GenericFLCollateralSwitchSubData.decode(subData)).to.eql({
+                    fromAsset,
+                    fromAssetId: 256,
+                    toAsset,
+                    toAssetId: 65535,
+                    marketAddr,
+                    amountToSwitch,
+                    user,
+                });
+            });
+        });
+    });
     describe('When testing subDataService.sparkCollateralSwitchSubData', () => {
         describe('encode()', () => {
             const examples = [

package/esm/types/enums.d.ts

@@ -93,28 +93,32 @@ export declare namespace Strategies {
         SPARK_COLLATERAL_SWITCH = 156,
         SPARK_GENERIC_FL_COLLATERAL_SWITCH = 167,
         AAVE_V3_DEBT_SWITCH = 168,
-        AAVE_V3_DEBT_SWITCH_EOA = 169
+        AAVE_V3_DEBT_SWITCH_EOA = 169,
+        AAVE_V3_COLLATERAL_SWITCH_EOA = 170
     }
     enum OptimismIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
         AAVE_V3_COLLATERAL_SWITCH = 24,
         AAVE_V3_DEBT_SWITCH = 25,
-        AAVE_V3_DEBT_SWITCH_EOA = 26
+        AAVE_V3_DEBT_SWITCH_EOA = 26,
+        AAVE_V3_COLLATERAL_SWITCH_EOA = 27
     }
     enum BaseIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
         AAVE_V3_COLLATERAL_SWITCH = 56,
         AAVE_V3_DEBT_SWITCH = 61,
-        AAVE_V3_DEBT_SWITCH_EOA = 62
+        AAVE_V3_DEBT_SWITCH_EOA = 62,
+        AAVE_V3_COLLATERAL_SWITCH_EOA = 63
     }
     enum ArbitrumIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
         AAVE_V3_COLLATERAL_SWITCH = 50,
         AAVE_V3_DEBT_SWITCH = 55,
-        AAVE_V3_DEBT_SWITCH_EOA = 56
+        AAVE_V3_DEBT_SWITCH_EOA = 56,
+        AAVE_V3_COLLATERAL_SWITCH_EOA = 57
     }
     enum Identifiers {
         SavingsLiqProtection = "smart-savings-liquidation-protection",

package/esm/types/enums.js

@@ -107,6 +107,7 @@ export var Strategies;
         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[MainnetIds["AAVE_V3_COLLATERAL_SWITCH_EOA"] = 170] = "AAVE_V3_COLLATERAL_SWITCH_EOA";
     })(MainnetIds = Strategies.MainnetIds || (Strategies.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {
@@ -115,6 +116,7 @@ export var Strategies;
         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[OptimismIds["AAVE_V3_COLLATERAL_SWITCH_EOA"] = 27] = "AAVE_V3_COLLATERAL_SWITCH_EOA";
     })(OptimismIds = Strategies.OptimismIds || (Strategies.OptimismIds = {}));
     let BaseIds;
     (function (BaseIds) {
@@ -123,6 +125,7 @@ export var Strategies;
         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[BaseIds["AAVE_V3_COLLATERAL_SWITCH_EOA"] = 63] = "AAVE_V3_COLLATERAL_SWITCH_EOA";
     })(BaseIds = Strategies.BaseIds || (Strategies.BaseIds = {}));
     let ArbitrumIds;
     (function (ArbitrumIds) {
@@ -131,6 +134,7 @@ export var Strategies;
         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[ArbitrumIds["AAVE_V3_COLLATERAL_SWITCH_EOA"] = 57] = "AAVE_V3_COLLATERAL_SWITCH_EOA";
     })(ArbitrumIds = Strategies.ArbitrumIds || (Strategies.ArbitrumIds = {}));
     let Identifiers;
     (function (Identifiers) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.21-debt-switch-dev-dev",
+  "version": "3.3.22-coll-switch-generic-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/constants/index.ts

@@ -125,6 +125,11 @@ export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.MainnetIds.AAVE_V3_COLLATERAL_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.MainnetIds.AAVE_V3_COLLATERAL_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
   [Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH]: {
     strategyOrBundleId: Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH,
     strategyId: Strategies.Identifiers.CollateralSwitch,
@@ -173,6 +178,11 @@ export const OPTIMISM_STRATEGIES_INFO: OptimismStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.OptimismIds.AAVE_V3_COLLATERAL_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.OptimismIds.AAVE_V3_COLLATERAL_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
   [Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH]: {
     strategyOrBundleId: Strategies.OptimismIds.AAVE_V3_DEBT_SWITCH,
     strategyId: Strategies.Identifiers.DebtSwitch,
@@ -201,6 +211,11 @@ export const BASE_STRATEGIES_INFO: BaseStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.BaseIds.AAVE_V3_COLLATERAL_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.BaseIds.AAVE_V3_COLLATERAL_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
   [Strategies.BaseIds.AAVE_V3_DEBT_SWITCH]: {
     strategyOrBundleId: Strategies.BaseIds.AAVE_V3_DEBT_SWITCH,
     strategyId: Strategies.Identifiers.DebtSwitch,
@@ -229,6 +244,11 @@ export const ARBITRUM_STRATEGIES_INFO: ArbitrumStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV3,
   },
+  [Strategies.ArbitrumIds.AAVE_V3_COLLATERAL_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.ArbitrumIds.AAVE_V3_COLLATERAL_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.AaveV3,
+  },
   [Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH]: {
     strategyOrBundleId: Strategies.ArbitrumIds.AAVE_V3_DEBT_SWITCH,
     strategyId: Strategies.Identifiers.DebtSwitch,

package/src/services/strategiesService.test.ts

@@ -1,12 +1,113 @@
 import { expect } from 'chai';
 
-import { ProtocolIdentifiers, Strategies } from '../types/enums';
+import { ChainId, ProtocolIdentifiers, RatioState, Strategies } from '../types/enums';
 import type { ParseData, Position } from '../types';
 
 import '../configuration';
 import { parseStrategiesAutomatedPosition } from './strategiesService';
 
 describe('Feature: strategiesService.ts', () => {
+  describe('When parsing Aave V3 collateral switch subscriptions', () => {
+    const proxy = '0x9cB7E19861665366011899d74E75d4F2A419aEeD';
+    const user = '0x1234567890123456789012345678901234567890';
+    const fromAsset = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+    const toAsset = '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf';
+    const marketAddr = '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e';
+    const amountToSwitch = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+    const subHash = `0x${'ab'.repeat(32)}`;
+    const triggerData = [
+      '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+      + '000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf'
+      + '0000000000000000000000000000000000000000000000000000000000989680'
+      + '0000000000000000000000000000000000000000000000000000000000000001',
+    ];
+
+    function getParseData(strategyId: number, isGeneric: boolean, chainId = ChainId.Ethereum): ParseData {
+      const subData = [
+        '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        isGeneric
+          ? '0x0000000000000000000000000000000000000000000000000000000000000100'
+          : '0x0000000000000000000000000000000000000000000000000000000000000000',
+        '0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+        isGeneric
+          ? '0x000000000000000000000000000000000000000000000000000000000000ffff'
+          : '0x0000000000000000000000000000000000000000000000000000000000000007',
+        '0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e',
+        '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+        isGeneric
+          ? '0x0000000000000000000000001234567890123456789012345678901234567890'
+          : '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ];
+      const subStruct = Object.assign(
+        [String(strategyId), false, triggerData, subData] as [string, boolean, string[], string[]],
+        { strategyOrBundleId: String(strategyId), isBundle: false, triggerData, subData },
+      );
+      return {
+        chainId,
+        blockNumber: 18015756,
+        subscriptionEventData: {
+          subId: '379', proxy, subHash, subStruct,
+          0: '379', 1: proxy, 2: subHash, 3: subStruct,
+        },
+        strategiesSubsData: {
+          userProxy: proxy, isEnabled: true, strategySubHash: subHash,
+        },
+      };
+    }
+
+    const genericStrategies: Array<[ChainId, number]> = [
+      [ChainId.Ethereum, Strategies.MainnetIds.AAVE_V3_COLLATERAL_SWITCH_EOA],
+      [ChainId.Optimism, Strategies.OptimismIds.AAVE_V3_COLLATERAL_SWITCH_EOA],
+      [ChainId.Arbitrum, Strategies.ArbitrumIds.AAVE_V3_COLLATERAL_SWITCH_EOA],
+      [ChainId.Base, Strategies.BaseIds.AAVE_V3_COLLATERAL_SWITCH_EOA],
+    ];
+    genericStrategies.forEach(([chainId, strategyId]) => {
+      it(`decodes generic collateral switches with the user and uint16 reserve IDs on chain ${chainId}`, () => {
+        const parseData = getParseData(strategyId, true, chainId);
+        const position = parseStrategiesAutomatedPosition(parseData)!;
+
+        expect(position).not.to.equal(null);
+        expect(position.protocol.id).to.equal(ProtocolIdentifiers.StrategiesAutomation.AaveV3);
+        expect(position.strategy.strategyId).to.equal(Strategies.Identifiers.EoaCollateralSwitch);
+        expect(position.strategy.isBundle).to.equal(false);
+        expect(position.strategyData.encoded).to.eql({
+          triggerData,
+          subData: parseData.subscriptionEventData.subStruct.subData,
+        });
+        expect(position.strategyData.decoded.triggerData).to.eql({
+          baseTokenAddress: fromAsset,
+          quoteTokenAddress: toAsset,
+          price: '0.1',
+          ratioState: RatioState.UNDER,
+        });
+        expect(position.strategyData.decoded.subData).to.eql({
+          fromAsset, fromAssetId: 256, toAsset, toAssetId: 65535, marketAddr, amountToSwitch, user,
+        });
+        expect(position.owner).to.equal(proxy.toLowerCase());
+        expect(position.positionId).to.equal(`${chainId}-aave__v3-${proxy.toLowerCase()}-${marketAddr.toLowerCase()}`);
+      });
+    });
+
+    const legacyStrategies: Array<[ChainId, number]> = [
+      [ChainId.Ethereum, Strategies.MainnetIds.AAVE_V3_COLLATERAL_SWITCH],
+      [ChainId.Optimism, Strategies.OptimismIds.AAVE_V3_COLLATERAL_SWITCH],
+      [ChainId.Arbitrum, Strategies.ArbitrumIds.AAVE_V3_COLLATERAL_SWITCH],
+      [ChainId.Base, Strategies.BaseIds.AAVE_V3_COLLATERAL_SWITCH],
+    ];
+    legacyStrategies.forEach(([chainId, strategyId]) => {
+      it(`continues to decode legacy collateral switches on chain ${chainId}`, () => {
+        const position = parseStrategiesAutomatedPosition(getParseData(strategyId, false, chainId))!;
+
+        expect(position).not.to.equal(null);
+        expect(position.strategy.strategyId).to.equal(Strategies.Identifiers.CollateralSwitch);
+        expect(position.strategyData.decoded.subData).to.eql({
+          fromAsset, fromAssetId: 0, toAsset, toAssetId: 7, marketAddr, amountToSwitch,
+        });
+        expect(position.positionId).to.equal(`${chainId}-aave__v3-${proxy.toLowerCase()}-${marketAddr.toLowerCase()}`);
+      });
+    });
+  });
+
   describe('When testing strategiesService.parseStrategiesAutomatedPosition', async () => {
     // TODO: we should probably write this for every strategy?
     const examples: Array<[Position.Automated | null, ParseData]> = [

package/src/services/strategiesService.ts

@@ -436,11 +436,17 @@ function parseAaveV3CloseOnPrice(position: Position.Automated, parseData: ParseD
 function parseAaveV3CollateralSwitch(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.aaveV3QuotePriceTrigger.decode(subStruct.triggerData);
-  const subData = subDataService.aaveV3CollateralSwitchSubData.decode(subStruct.subData);
+  const subData = isEOA
+    ? subDataService.aaveV3GenericFLCollateralSwitchSubData.decode(subStruct.subData)
+    : subDataService.aaveV3CollateralSwitchSubData.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;
 }
@@ -1610,6 +1616,7 @@ const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
     [Strategies.Identifiers.EoaBoostOnPrice]: parseAaveV3LeverageManagementOnPrice,
     [Strategies.Identifiers.EoaCloseOnPrice]: parseAaveV3CloseOnPrice,
     [Strategies.Identifiers.CollateralSwitch]: parseAaveV3CollateralSwitch,
+    [Strategies.Identifiers.EoaCollateralSwitch]: parseAaveV3CollateralSwitch,
     [Strategies.Identifiers.DebtSwitch]: parseAaveV3DebtSwitch,
     [Strategies.Identifiers.EoaDebtSwitch]: parseAaveV3DebtSwitch,
     [Strategies.Identifiers.LiquidationProtection]: parseAaveV3LiquidationProtection,

package/src/services/strategySubService.test.ts

@@ -1003,6 +1003,48 @@ describe('Feature: strategySubService.ts', () => {
       });
     });
 
+    describe('collateralSwitchGeneric()', () => {
+      const strategyId = 12345;
+      const fromAsset = web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address);
+      const toAsset = web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address);
+      const marketAddr = web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39');
+      const user = web3Utils.toChecksumAddress('0x1234567890abcdef1234567890abcdef12345678');
+      const examples: Array<[RatioState, string, string, string]> = [
+        [
+          RatioState.UNDER,
+          '10000000000000000000',
+          '0x0000000000000000000000000000000000000000000000008ac7230489e80000',
+          '0000000000000000000000000000000000000000000000000000000000000001',
+        ],
+        [
+          RatioState.OVER,
+          MAXUINT,
+          '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        ],
+      ];
+
+      examples.forEach(([state, amountToSwitch, encodedAmount, encodedState]) => {
+        it(`encodes a generic collateral switch with the supplied quote pair and state ${state}`, () => {
+          const expectedTrigger = `0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000000000003e8${encodedState}`;
+          const expectedSubData: SubData = [
+            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+            '0x0000000000000000000000000000000000000000000000000000000000000100',
+            '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            '0x000000000000000000000000000000000000000000000000000000000000ffff',
+            '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+            encodedAmount,
+            '0x0000000000000000000000001234567890abcdef1234567890abcdef12345678',
+          ];
+
+          expect(aaveV3Encode.collateralSwitchGeneric(
+            strategyId, fromAsset, 256, toAsset, 65535, marketAddr, amountToSwitch, user,
+            toAsset, fromAsset, 0.00001, state,
+          )).to.eql([strategyId, false, [expectedTrigger], expectedSubData]);
+        });
+      });
+    });
+
     describe('debtSwitch()', () => {
       const examples: Array<[
         [StrategyOrBundleIds, boolean, TriggerData, SubData],

package/src/services/strategySubService.ts

@@ -445,6 +445,30 @@ export const aaveV3Encode = {
     return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
   },
 
+  collateralSwitchGeneric(
+    strategyOrBundleId: number,
+    fromAsset: EthereumAddress,
+    fromAssetId: number,
+    toAsset: EthereumAddress,
+    toAssetId: number,
+    marketAddr: EthereumAddress,
+    amountToSwitch: string,
+    user: EthereumAddress,
+    baseTokenAddress: EthereumAddress,
+    quoteTokenAddress: EthereumAddress,
+    price: number,
+    state: RatioState,
+  ) {
+    const isBundle = false;
+
+    const subDataEncoded = subDataService.aaveV3GenericFLCollateralSwitchSubData.encode(
+      fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user,
+    );
+    const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
+
+    return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+  },
+
   debtSwitch(
     strategyOrBundleId: number,
     fromAsset: EthereumAddress,

package/src/services/subDataService.test.ts

@@ -657,6 +657,47 @@ describe('Feature: subDataService.ts', () => {
     });
   });
 
+  describe('When testing subDataService.aaveV3GenericFLCollateralSwitchSubData', () => {
+    const fromAsset = web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address);
+    const toAsset = web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address);
+    const marketAddr = web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39');
+    const user = web3Utils.toChecksumAddress('0x1234567890abcdef1234567890abcdef12345678');
+    const examples = [
+      ['10000000000000000000', '0x0000000000000000000000000000000000000000000000008ac7230489e80000'],
+      [MAXUINT, '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'],
+    ];
+
+    examples.forEach(([amountToSwitch, encodedAmount]) => {
+      const subData: SubData = [
+        '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        '0x0000000000000000000000000000000000000000000000000000000000000100',
+        '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+        '0x000000000000000000000000000000000000000000000000000000000000ffff',
+        '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+        encodedAmount,
+        '0x0000000000000000000000001234567890abcdef1234567890abcdef12345678',
+      ];
+
+      it(`encode() preserves uint16 asset IDs and user when switching ${amountToSwitch}`, () => {
+        expect(subDataService.aaveV3GenericFLCollateralSwitchSubData.encode(
+          fromAsset, 256, toAsset, 65535, marketAddr, amountToSwitch, user,
+        )).to.eql(subData);
+      });
+
+      it(`decode() preserves uint16 asset IDs and user when switching ${amountToSwitch}`, () => {
+        expect(subDataService.aaveV3GenericFLCollateralSwitchSubData.decode(subData)).to.eql({
+          fromAsset,
+          fromAssetId: 256,
+          toAsset,
+          toAssetId: 65535,
+          marketAddr,
+          amountToSwitch,
+          user,
+        });
+      });
+    });
+  });
+
   describe('When testing subDataService.sparkCollateralSwitchSubData', () => {
     describe('encode()', () => {
       const examples: Array<[SubData, [fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, useOnBehalf?: boolean]]> = [

package/src/services/subDataService.ts

@@ -735,6 +735,57 @@ export const aaveV3CollateralSwitchSubData = {
     };
   },
 };
+export const aaveV3GenericFLCollateralSwitchSubData = {
+  encode(
+    fromAsset: EthereumAddress,
+    fromAssetId: number,
+    toAsset: EthereumAddress,
+    toAssetId: number,
+    marketAddr: EthereumAddress,
+    amountToSwitch: string,
+    user: EthereumAddress,
+  ): SubData {
+    const encodedFromAsset = AbiCoder.encodeParameter('address', fromAsset);
+    const encodedFromAssetId = AbiCoder.encodeParameter('uint16', fromAssetId);
+    const encodedToAsset = AbiCoder.encodeParameter('address', toAsset);
+    const encodedToAssetId = AbiCoder.encodeParameter('uint16', toAssetId);
+    const encodedMarketAddr = AbiCoder.encodeParameter('address', marketAddr);
+    const encodedAmountToSwitch = AbiCoder.encodeParameter('uint256', amountToSwitch);
+    const encodedUser = AbiCoder.encodeParameter('address', user);
+
+    return [
+      encodedFromAsset,
+      encodedFromAssetId,
+      encodedToAsset,
+      encodedToAssetId,
+      encodedMarketAddr,
+      encodedAmountToSwitch,
+      encodedUser,
+    ];
+  },
+  decode(subData: SubData): {
+    fromAsset: EthereumAddress,
+    fromAssetId: number,
+    toAsset: EthereumAddress,
+    toAssetId: number,
+    marketAddr: EthereumAddress,
+    amountToSwitch: string,
+    user: EthereumAddress,
+  } {
+    const fromAsset = AbiCoder.decodeParameter('address', subData[0]) as unknown as EthereumAddress;
+    const fromAssetId = Number(AbiCoder.decodeParameter('uint16', subData[1]));
+    const toAsset = AbiCoder.decodeParameter('address', subData[2]) as unknown as EthereumAddress;
+    const toAssetId = Number(AbiCoder.decodeParameter('uint16', subData[3]));
+    const marketAddr = AbiCoder.decodeParameter('address', subData[4]) as unknown as EthereumAddress;
+    const amountToSwitch = AbiCoder.decodeParameter('uint256', subData[5]) as unknown as string;
+    const user = AbiCoder.decodeParameter('address', subData[6]) as unknown as EthereumAddress;
+
+    return {
+      fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, user,
+    };
+  },
+};
+
 export const aaveV3DebtSwitchSubData = {
   encode(
     fromAsset: EthereumAddress,

package/src/types/enums.ts

@@ -104,6 +104,7 @@ export namespace Strategies {
     SPARK_GENERIC_FL_COLLATERAL_SWITCH = 167,
     AAVE_V3_DEBT_SWITCH = 168,
     AAVE_V3_DEBT_SWITCH_EOA = 169,
+    AAVE_V3_COLLATERAL_SWITCH_EOA = 170,
   }
 
   export enum OptimismIds {
@@ -112,6 +113,7 @@ export namespace Strategies {
     AAVE_V3_COLLATERAL_SWITCH = 24,
     AAVE_V3_DEBT_SWITCH = 25,
     AAVE_V3_DEBT_SWITCH_EOA = 26,
+    AAVE_V3_COLLATERAL_SWITCH_EOA = 27,
   }
 
   export enum BaseIds {
@@ -120,6 +122,7 @@ export namespace Strategies {
     AAVE_V3_COLLATERAL_SWITCH = 56,
     AAVE_V3_DEBT_SWITCH = 61,
     AAVE_V3_DEBT_SWITCH_EOA = 62,
+    AAVE_V3_COLLATERAL_SWITCH_EOA = 63,
   }
 
   export enum ArbitrumIds {
@@ -128,6 +131,7 @@ export namespace Strategies {
     AAVE_V3_COLLATERAL_SWITCH = 50,
     AAVE_V3_DEBT_SWITCH = 55,
     AAVE_V3_DEBT_SWITCH_EOA = 56,
+    AAVE_V3_COLLATERAL_SWITCH_EOA = 57,
   }
 
   export enum Identifiers {