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

package/cjs/types/enums.d.ts

@@ -91,22 +91,30 @@ export declare namespace Strategies {
         AAVE_V4_COLLATERAL_SWITCH = 154,
         AAVE_V4_COLLATERAL_SWITCH_EOA = 155,
         SPARK_COLLATERAL_SWITCH = 156,
-        SPARK_GENERIC_FL_COLLATERAL_SWITCH = 167
+        SPARK_GENERIC_FL_COLLATERAL_SWITCH = 167,
+        AAVE_V3_DEBT_SWITCH = 168,
+        AAVE_V3_DEBT_SWITCH_EOA = 169
     }
     enum OptimismIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
-        AAVE_V3_COLLATERAL_SWITCH = 24
+        AAVE_V3_COLLATERAL_SWITCH = 24,
+        AAVE_V3_DEBT_SWITCH = 25,
+        AAVE_V3_DEBT_SWITCH_EOA = 26
     }
     enum BaseIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
-        AAVE_V3_COLLATERAL_SWITCH = 56
+        AAVE_V3_COLLATERAL_SWITCH = 56,
+        AAVE_V3_DEBT_SWITCH = 61,
+        AAVE_V3_DEBT_SWITCH_EOA = 62
     }
     enum ArbitrumIds {
         EXCHANGE_DCA = 8,
         EXCHANGE_LIMIT_ORDER = 9,
-        AAVE_V3_COLLATERAL_SWITCH = 50
+        AAVE_V3_COLLATERAL_SWITCH = 50,
+        AAVE_V3_DEBT_SWITCH = 55,
+        AAVE_V3_DEBT_SWITCH_EOA = 56
     }
     enum Identifiers {
         SavingsLiqProtection = "smart-savings-liquidation-protection",
@@ -140,6 +148,8 @@ export declare namespace Strategies {
         EoaRepayOnPrice = "eoa-repay-on-price",
         CollateralSwitch = "collateral-switch",
         EoaCollateralSwitch = "eoa-collateral-switch",
+        DebtSwitch = "debt-switch",
+        EoaDebtSwitch = "eoa-debt-switch",
         LiquidationProtection = "liquidation-protection",
         EoaLiquidationProtection = "liquidation-protection-eoa"
     }

package/cjs/types/enums.js

@@ -108,24 +108,32 @@ 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) {
@@ -160,6 +168,8 @@ 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 = {}));

package/esm/constants/index.js

@@ -121,6 +121,16 @@ export const MAINNET_STRATEGIES_INFO = {
         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 = {
     [Strategies.OptimismIds.EXCHANGE_DCA]: {
@@ -138,6 +148,16 @@ export const OPTIMISM_STRATEGIES_INFO = {
         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 = {
     [Strategies.BaseIds.EXCHANGE_DCA]: {
@@ -155,6 +175,16 @@ export const BASE_STRATEGIES_INFO = {
         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 = {
     [Strategies.ArbitrumIds.EXCHANGE_DCA]: {
@@ -172,6 +202,16 @@ export const ARBITRUM_STRATEGIES_INFO = {
         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 = {
     [ChainId.Ethereum]: MAINNET_STRATEGIES_INFO,

package/esm/services/strategiesService.js

@@ -318,12 +318,29 @@ function parseAaveV3CloseOnPrice(position, parseData) {
     return _position;
 }
 function parseAaveV3CollateralSwitch(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    const triggerData = triggerService.aaveV3QuotePriceTrigger.decode(subStruct.triggerData);
+    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;
+}
+function parseAaveV3DebtSwitch(position, parseData) {
     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;
+    // TODO -> This isn't enough for ID
     _position.positionId = getPositionId(_position.chainId, _position.protocol.id, _position.owner, subData.marketAddr);
     return _position;
 }
@@ -1217,6 +1234,9 @@ const parsingMethodsMapping = {
         [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,
         [Strategies.Identifiers.EoaLiquidationProtection]: parseAaveV3LiquidationProtection,
     },

package/esm/services/strategiesService.test.js

@@ -8,10 +8,104 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { expect } from 'chai';
-import { ProtocolIdentifiers, Strategies } from '../types/enums';
+import { ChainId, ProtocolIdentifiers, RatioState, Strategies } from '../types/enums';
+import { MAINNET_STRATEGIES_INFO } from '../constants';
 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, isGeneric, chainId = ChainId.Ethereum) {
+            const subData = [
+                '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                isGeneric
+                    ? '0x0000000000000000000000000000000000000000000000000000000000000100'
+                    : '0x0000000000000000000000000000000000000000000000000000000000000000',
+                '0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+                isGeneric
+                    ? '0x000000000000000000000000000000000000000000000000000000000000ffff'
+                    : '0x0000000000000000000000000000000000000000000000000000000000000007',
+                '0x0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e',
+                '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+                isGeneric
+                    ? '0x0000000000000000000000001234567890123456789012345678901234567890'
+                    : '0x0000000000000000000000000000000000000000000000000000000000000000',
+            ];
+            const subStruct = Object.assign([String(strategyId), false, triggerData, subData], { 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,
+                },
+            };
+        }
+        it('decodes generic collateral switches with the user and uint16 reserve IDs', () => {
+            const strategyId = Strategies.MainnetIds.AAVE_V3_COLLATERAL_SWITCH;
+            const originalInfo = MAINNET_STRATEGIES_INFO[strategyId];
+            const parseData = getParseData(strategyId, true);
+            let position;
+            MAINNET_STRATEGIES_INFO[strategyId] = Object.assign(Object.assign({}, originalInfo), { strategyId: Strategies.Identifiers.EoaCollateralSwitch });
+            try {
+                position = parseStrategiesAutomatedPosition(parseData);
+            }
+            finally {
+                MAINNET_STRATEGIES_INFO[strategyId] = originalInfo;
+            }
+            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(`1-aave__v3-${proxy.toLowerCase()}-${marketAddr.toLowerCase()}`);
+        });
+        const legacyStrategies = [
+            [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', () => __awaiter(void 0, void 0, void 0, function* () {
         // TODO: we should probably write this for every strategy?
         const examples = [

package/esm/services/strategySubService.d.ts

@@ -62,6 +62,8 @@ export declare const aaveV3Encode: {
     leverageManagementOnPriceGeneric(strategyOrBundleId: number, price: number, ratioState: RatioState, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, targetRatio: number, user: EthereumAddress): (number | boolean | string[])[];
     closeOnPriceGeneric(strategyOrBundleId: number, collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, user: EthereumAddress, stopLossPrice?: number, stopLossType?: CloseToAssetType, takeProfitPrice?: number, takeProfitType?: CloseToAssetType): (number | boolean | string[])[];
     collateralSwitch(strategyOrBundleId: number, fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, state: RatioState): (number | boolean | string[])[];
+    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): (number | boolean | string[])[];
+    debtSwitch(strategyOrBundleId: number, fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, user: EthereumAddress, baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, state: RatioState): (number | boolean | string[])[];
 };
 export declare const compoundV2Encode: {
     leverageManagement(strategyOrBundleId: number, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];

package/esm/services/strategySubService.js

@@ -170,6 +170,18 @@ 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);
+        const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
+        return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+    },
 };
 export const compoundV2Encode = {
     leverageManagement(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {

package/esm/services/strategySubService.test.js

@@ -831,6 +831,113 @@ 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
+                [
+                    [
+                        Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH,
+                        false,
+                        ['0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000000000000000000000000000000009184e72a0000000000000000000000000000000000000000000000000000000000000000001'],
+                        [
+                            '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                            '0x0000000000000000000000000000000000000000000000000000000000000001',
+                            '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f',
+                            '0x0000000000000000000000000000000000000000000000000000000000000003',
+                            '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+                            '0x0000000000000000000000000000000000000000000000008ac7230489e80000',
+                            '0x000000000000000000000000dd6ecd6c9b9f7e29e0f14bb9d5f0d0a3c6cb6c6a',
+                        ],
+                    ],
+                    [
+                        Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH,
+                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        1,
+                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        3,
+                        web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39'),
+                        '10000000000000000000',
+                        web3Utils.toChecksumAddress('0xDd6ecD6c9b9F7e29E0f14bb9D5F0D0A3C6cB6c6A'),
+                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        100000,
+                        RatioState.UNDER,
+                    ]
+                ],
+                // DAI -> USDC (MaxUint256), price 1, state OVER
+                [
+                    [
+                        Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH,
+                        false,
+                        ['0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000000005f5e1000000000000000000000000000000000000000000000000000000000000000000'],
+                        [
+                            '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f',
+                            '0x0000000000000000000000000000000000000000000000000000000000000003',
+                            '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                            '0x0000000000000000000000000000000000000000000000000000000000000001',
+                            '0x00000000000000000000000087870bca3f3fd6335c3f4ce8392d69d0b4161d39',
+                            '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+                            '0x000000000000000000000000dd6ecd6c9b9f7e29e0f14bb9d5f0d0a3c6cb6c6a',
+                        ],
+                    ],
+                    [
+                        Strategies.MainnetIds.AAVE_V3_DEBT_SWITCH,
+                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        3,
+                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        1,
+                        web3Utils.toChecksumAddress('0x87870Bca3F3fD6335C3F4ce8392D69d0B4161d39'),
+                        MAXUINT,
+                        web3Utils.toChecksumAddress('0xDd6ecD6c9b9F7e29E0f14bb9D5F0D0A3C6cB6c6A'),
+                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        1,
+                        RatioState.OVER,
+                    ]
+                ],
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(aaveV3Encode.debtSwitch(...actual)).to.eql(expected);
+                });
+            });
+        });
     });
     describe('When testing strategySubService.compoundV3Encode', () => {
         describe('leverageManagementOnPrice()', () => {

package/esm/services/subDataService.d.ts

@@ -259,6 +259,30 @@ 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[]): {
+        fromAsset: EthereumAddress;
+        fromAssetId: number;
+        toAsset: EthereumAddress;
+        toAssetId: number;
+        marketAddr: EthereumAddress;
+        amountToSwitch: string;
+        user: EthereumAddress;
+    };
+};
 export declare const aaveV3QuotePriceSubData: {
     encode(collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, nullAddress?: EthereumAddress): string[];
     decode(subData: string[]): {

package/esm/services/subDataService.js

@@ -542,6 +542,70 @@ 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);
+        const encodedFromAssetId = AbiCoder.encodeParameter('uint8', fromAssetId);
+        const encodedToAsset = AbiCoder.encodeParameter('address', toAsset);
+        const encodedToAssetId = AbiCoder.encodeParameter('uint8', 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('uint8', subData[1]));
+        const toAsset = AbiCoder.decodeParameter('address', subData[2]);
+        const toAssetId = Number(AbiCoder.decodeParameter('uint8', 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 aaveV3QuotePriceSubData = {
     encode(collAsset, collAssetId, debtAsset, debtAssetId, nullAddress = ZERO_ADDRESS) {
         const encodedColl = AbiCoder.encodeParameter('address', collAsset);