@defisaver/automation-sdk 3.3.12 → 3.3.13-strategies-refactor-dev

package/esm/services/strategySubService.js

@@ -1,4 +1,3 @@
-import Dec from 'decimal.js';
 import { getAssetInfo } from '@defisaver/tokens';
 import { CloseToAssetType, Bundles, ChainId, RatioState, Strategies, } from '../types/enums';
 import { STRATEGY_IDS } from '../constants';
@@ -31,16 +30,6 @@ export const makerEncode = {
         const isBundle = false;
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
-    leverageManagement(vaultId, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        return [
-            vaultId,
-            new Dec(triggerRepayRatio).mul(1e16).toString(),
-            new Dec(triggerBoostRatio).mul(1e16).toString(),
-            new Dec(targetBoostRatio).mul(1e16).toString(),
-            new Dec(targetRepayRatio).mul(1e16).toString(),
-            boostEnabled,
-        ];
-    },
     leverageManagementWithoutSubProxy(vaultId, triggerRatio, targetRatio, ratioState, isBoost, daiAddr) {
         const bundleId = isBoost ? Bundles.MainnetIds.MAKER_BOOST : Bundles.MainnetIds.MAKER_REPAY;
         const triggerData = triggerService.makerRatioTrigger.encode(vaultId, triggerRatio, ratioState);
@@ -78,14 +67,11 @@ export const liquityEncode = {
         const isBundle = true;
         return [strategyId, isBundle, triggerData, subData];
     },
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        return [
-            new Dec(triggerRepayRatio).mul(1e16).toString(),
-            new Dec(triggerBoostRatio).mul(1e16).toString(),
-            new Dec(targetBoostRatio).mul(1e16).toString(),
-            new Dec(targetRepayRatio).mul(1e16).toString(),
-            boostEnabled,
-        ];
+    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.liquityLeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const triggerData = triggerService.liquityRatioTrigger.encode(user, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
     },
     dsrPayback(proxyAddress, triggerRatio, targetRatio) {
         requireAddress(proxyAddress);
@@ -118,24 +104,14 @@ export const chickenBondsEncode = {
     },
 };
 export const aaveV2Encode = {
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        return subDataService.aaveV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
+    leverageManagementWithoutSubProxy(strategyOrBundleId, market, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.aaveV2LeverageManagementSubDataWithoutSubProxy.encode(market, targetRatio, ratioState);
+        const triggerData = triggerService.aaveV2RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
 export const aaveV3Encode = {
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        let subInput = '0x';
-        subInput = subInput.concat(new Dec(triggerRepayRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(triggerBoostRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(targetBoostRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(targetRepayRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(boostEnabled ? '01' : '00');
-        return subInput;
-    },
     closeToAsset(strategyOrBundleId, isBundle = true, triggerData, subData) {
         const { collAsset, collAssetId, debtAsset, debtAssetId, } = subData;
         const subDataEncoded = subDataService.aaveV3QuotePriceSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId);
@@ -184,13 +160,19 @@ export const aaveV3Encode = {
     },
 };
 export const compoundV2Encode = {
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        return subDataService.compoundV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
+    leverageManagementWithoutSubProxy(strategyOrBundleId, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.compoundV2LeverageManagementSubDataWithoutSubProxy.encode(targetRatio, ratioState);
+        const triggerData = triggerService.compoundV2RatioTrigger.encode(user, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
     },
 };
 export const compoundV3Encode = {
-    leverageManagement(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA) {
-        return subDataService.compoundV3LeverageManagementSubData.encode(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA);
+    leverageManagementWithoutSubProxy(strategyOrBundleId, market, baseToken, user, ratioState, targetRatio, triggerRatio) {
+        const isBundle = true;
+        const subData = subDataService.compoundV3LeverageManagementSubDataWithoutSubProxy.encode(market, baseToken, targetRatio, ratioState);
+        const triggerData = triggerService.compoundV3RatioTrigger.encode(user, market, triggerRatio, ratioState);
+        return [strategyOrBundleId, isBundle, triggerData, subData];
     },
     leverageManagementOnPrice(strategyOrBundleId, market, collToken, baseToken, targetRatio, price, priceState, ratioState, // REPAY for repay on price, BOOST for boost on price
     user) {
@@ -207,11 +189,6 @@ export const compoundV3Encode = {
         return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
     },
 };
-export const compoundV3L2Encode = {
-    leverageManagement(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA = false) {
-        return subDataService.compoundV3L2LeverageManagementSubData.encode(market, baseToken, triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled, isEOA);
-    },
-};
 export const morphoAaveV2Encode = {
     leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
         return subDataService.morphoAaveV2LeverageManagementSubData.encode(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled);
@@ -225,24 +202,15 @@ export const exchangeEncode = {
         const strategyId = STRATEGY_IDS[network].EXCHANGE_DCA;
         return [strategyId, false, triggerData, subData];
     },
-    limitOrder(fromToken, toToken, amount, targetPrice, goodUntil, orderType) {
-        return subDataService.exchangeLimitOrderSubData.encode(fromToken, toToken, amount, targetPrice, goodUntil, orderType);
+    limitOrderWithoutSubProxy(fromToken, toToken, amount, targetPrice, goodUntil, orderType, fromTokenDecimals, toTokenDecimals, network) {
+        requireAddresses([fromToken, toToken]);
+        const subData = subDataService.exchangeLimitOrderSubDataWithoutSubProxy.encode(fromToken, toToken, amount);
+        const triggerData = triggerService.exchangeOffchainPriceTrigger.encode(targetPrice, Number(goodUntil), orderType, fromTokenDecimals, toTokenDecimals);
+        const strategyId = STRATEGY_IDS[network].EXCHANGE_LIMIT_ORDER;
+        return [strategyId, false, triggerData, subData];
     },
 };
 export const sparkEncode = {
-    leverageManagement(triggerRepayRatio, triggerBoostRatio, targetBoostRatio, targetRepayRatio, boostEnabled) {
-        let subInput = '0x';
-        subInput = subInput.concat(new Dec(triggerRepayRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(triggerBoostRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(targetBoostRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(new Dec(targetRepayRatio).mul(1e16).toHex().slice(2)
-            .padStart(32, '0'));
-        subInput = subInput.concat(boostEnabled ? '01' : '00');
-        return subInput;
-    },
     leverageManagementOnPrice(strategyOrBundleId, isBundle = true, triggerData, subData) {
         const { collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio, } = subData;
         const subDataEncoded = subDataService.sparkLeverageManagementOnPriceSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio);
@@ -263,6 +231,12 @@ export const sparkEncode = {
         const triggerData = triggerService.sparkRatioTrigger.encode(user, market, triggerRatio, ratioState);
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
+    collateralSwitch(strategyOrBundleId, fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch, baseTokenAddress, quoteTokenAddress, price, state) {
+        const isBundle = false;
+        const subDataEncoded = subDataService.sparkCollateralSwitchSubData.encode(fromAsset, fromAssetId, toAsset, toAssetId, marketAddr, amountToSwitch);
+        const triggerDataEncoded = triggerService.sparkQuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, state);
+        return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+    },
 };
 export const crvUSDEncode = {
     leverageManagement(owner, controllerAddr, ratioState, targetRatio, triggerRatio, collTokenAddr, crvUSDAddr) {

package/esm/services/strategySubService.test.js

@@ -3,9 +3,9 @@ import Dec from 'decimal.js';
 import { otherAddresses } from '@defisaver/sdk';
 import { getAssetInfo, MAXUINT } from '@defisaver/tokens';
 import * as web3Utils from 'web3-utils';
-import { Bundles, ChainId, CloseToAssetType, OrderType, RatioState, Strategies } from '../types/enums';
+import { Bundles, ChainId, CloseToAssetType, RatioState, Strategies } from '../types/enums';
 import '../configuration';
-import { aaveV2Encode, chickenBondsEncode, liquityEncode, makerEncode, aaveV3Encode, compoundV2Encode, compoundV3Encode, morphoAaveV2Encode, exchangeEncode, crvUSDEncode, compoundV3L2Encode, morphoBlueEncode, sparkEncode, aaveV4Encode, } from './strategySubService';
+import { chickenBondsEncode, liquityEncode, makerEncode, aaveV3Encode, compoundV3Encode, morphoAaveV2Encode, exchangeEncode, crvUSDEncode, morphoBlueEncode, sparkEncode, aaveV4Encode, } from './strategySubService';
 describe('Feature: strategySubService.ts', () => {
     describe('When testing strategySubService.makerEncode', () => {
         // @ts-ignore // TODO - this requires change in @defisaver/tokens
@@ -96,28 +96,6 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [
-                        5791,
-                        new Dec('210').mul(1e16).toString(),
-                        new Dec('290').mul(1e16).toString(),
-                        new Dec('240').mul(1e16).toString(),
-                        new Dec('240').mul(1e16).toString(),
-                        true,
-                    ],
-                    [
-                        5791, '210', '290', '240', '240', true,
-                    ]
-                ]
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(makerEncode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
         describe('leverageManagementWithoutSubProxy()', () => {
             const examples = [
                 // Repay scenario (isBoost=false, RatioState.UNDER)
@@ -217,27 +195,6 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [
-                        new Dec('210').mul(1e16).toString(),
-                        new Dec('290').mul(1e16).toString(),
-                        new Dec('240').mul(1e16).toString(),
-                        new Dec('240').mul(1e16).toString(),
-                        false,
-                    ],
-                    [
-                        '210', '290', '240', '240', false,
-                    ]
-                ]
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(liquityEncode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
         describe('paybackFromChickenBondStrategySub()', () => {
             const examples = [
                 [
@@ -324,43 +281,7 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
-    describe('When testing strategySubService.aaveV2Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(220).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), true],
-                    [160, 220, 180, 190, true]
-                ],
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(200).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), false],
-                    [160, 200, 180, 190, false]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(aaveV2Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
-    });
     describe('When testing strategySubService.aaveV3Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    '0x000000000000000016345785d8a0000000000000000000001e87f85809dc0000000000000000000018fae27693b4000000000000000000001a5e27eef13e000001',
-                    [160, 220, 180, 190, true]
-                ],
-                [
-                    '0x000000000000000016345785d8a0000000000000000000001bc16d674ec80000000000000000000018fae27693b4000000000000000000001a5e27eef13e000000',
-                    [160, 200, 180, 190, false]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(aaveV3Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
         describe('closeToAsset()', () => {
             const examples = [
                 [
@@ -927,69 +848,7 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
-    describe('When testing strategySubService.compoundV2Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(220).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), true],
-                    [160, 220, 180, 190, true]
-                ],
-                [
-                    [new Dec(160).mul(1e16).toString(), new Dec(200).mul(1e16).toString(), new Dec(180).mul(1e16).toString(), new Dec(190).mul(1e16).toString(), false],
-                    [160, 200, 180, 190, false]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(compoundV2Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
-    });
     describe('When testing strategySubService.compoundV3Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    [
-                        web3Utils.toChecksumAddress('0x1C0F620155e85491f8D35440eb17538Ca5c55212'),
-                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
-                        new Dec(160).mul(1e16).toString(),
-                        new Dec(220).mul(1e16).toString(),
-                        new Dec(180).mul(1e16).toString(),
-                        new Dec(190).mul(1e16).toString(),
-                        true, false,
-                    ],
-                    [
-                        web3Utils.toChecksumAddress('0x1C0F620155e85491f8D35440eb17538Ca5c55212'),
-                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
-                        160, 220, 180, 190,
-                        true, false,
-                    ]
-                ],
-                [
-                    [
-                        web3Utils.toChecksumAddress('0xaC0F620155e85491f8D35440eb17538Ca5c55212'),
-                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
-                        new Dec(160).mul(1e16).toString(),
-                        new Dec(210).mul(1e16).toString(),
-                        new Dec(180).mul(1e16).toString(),
-                        new Dec(190).mul(1e16).toString(),
-                        false, true,
-                    ],
-                    [
-                        web3Utils.toChecksumAddress('0xaC0F620155e85491f8D35440eb17538Ca5c55212'),
-                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
-                        160, 210, 180, 190,
-                        false, true,
-                    ]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(compoundV3Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
         describe('leverageManagementOnPrice()', () => {
             const examples = [
                 [
@@ -1164,51 +1023,6 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
-        describe('limitOrder()', () => {
-            const examples = [
-                [
-                    [
-                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
-                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
-                        '2131',
-                        '0.53123',
-                        '1696590921159',
-                        `${OrderType.STOP_LOSS}`
-                    ],
-                    [
-                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
-                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
-                        '2131',
-                        '0.53123',
-                        1696590921159,
-                        OrderType.STOP_LOSS
-                    ]
-                ],
-                [
-                    [
-                        web3Utils.toChecksumAddress(getAssetInfo('LINK', ChainId.Arbitrum).address),
-                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Arbitrum).address),
-                        '2131',
-                        '0.43123',
-                        '1646590921159',
-                        `${OrderType.TAKE_PROFIT}`
-                    ],
-                    [
-                        web3Utils.toChecksumAddress(getAssetInfo('LINK', ChainId.Arbitrum).address),
-                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Arbitrum).address),
-                        '2131',
-                        '0.43123',
-                        1646590921159,
-                        OrderType.TAKE_PROFIT
-                    ]
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(exchangeEncode.limitOrder(...actual)).to.eql(expected);
-                });
-            });
-        });
     });
     describe('When testing strategySubService.crvUSDEncode', () => {
         describe('leverageManagement()', () => {
@@ -1422,55 +1236,7 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
-    describe('When testing strategySubService.compoundV3L2Encode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    '0x0313D212133AFab8F2b829B1066c7e43caD94e2c0213D212133AfaB8F2b829B1066C7E43cAD94E2c000000000000000016345785d8a0000000000000000000001e87f85809dc0000000000000000000018fae27693b4000000000000000000001a5e27eef13e00000100',
-                    [
-                        web3Utils.toChecksumAddress('0x0313d212133AFaB8F2B829B1066c7E43cAd94E2c'),
-                        web3Utils.toChecksumAddress('0x0213d212133AFaB8F2B829B1066c7E43cAd94E2c'),
-                        160, 220, 180, 190,
-                        true,
-                        false,
-                    ],
-                ],
-                [
-                    '0x0313D212133AFab8F2b829B1066c7e43caD94e2c0413d212133afAb8F2B829b1066C7e43cAd94e2c000000000000000016345785d8a0000000000000000000001e87f85809dc0000000000000000000018fae27693b4000000000000000000000f43fc2c04ee00000000',
-                    [
-                        web3Utils.toChecksumAddress('0x0313d212133AFaB8F2B829B1066c7E43cAd94E2c'),
-                        web3Utils.toChecksumAddress('0x0413d212133AFaB8F2B829B1066c7E43cAd94E2c'),
-                        160, 220, 180, 110,
-                        false,
-                        false,
-                    ],
-                ],
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(compoundV3L2Encode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
-    });
     describe('When testing strategySubService.sparkEncode', () => {
-        describe('leverageManagement()', () => {
-            const examples = [
-                [
-                    '0x0000000000000000136dcc951d8c00000000000000000000214e8348c4f0000000000000000000001d24b2dfac52000000000000000000001a5e27eef13e000001',
-                    [140, 240, 210, 190, true]
-                ],
-                [
-                    '0x0000000000000000130337bdce49000000000000000000001988fe4052b800000000000000000000281b57b028e1000000000000000000002223acf76376000000',
-                    [137, 184, 289, 246, false]
-                ]
-            ];
-            examples.forEach(([expected, actual]) => {
-                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
-                    expect(sparkEncode.leverageManagement(...actual)).to.eql(expected);
-                });
-            });
-        });
         describe('leverageManagementOnPrice()', () => {
             const examples = [
                 [
@@ -1585,6 +1351,105 @@ describe('Feature: strategySubService.ts', () => {
                 });
             });
         });
+        describe('collateralSwitch()', () => {
+            const examples = [
+                // WETH -> cbBTC, price 0.025 WETH/cbBTC, state UNDER
+                [
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        false,
+                        ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf00000000000000000000000000000000000000000000000000000000002625a00000000000000000000000000000000000000000000000000000000000000001'],
+                        [
+                            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+                            '0x0000000000000000000000000000000000000000000000000000000000000007',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x0000000000000000000000000000000000000000000000008ac7230489e80000',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        ],
+                    ],
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        0,
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        7,
+                        web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        '10000000000000000000',
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        0.025,
+                        RatioState.UNDER,
+                    ]
+                ],
+                // cbBTC -> WETH, price 25 cbBTC/WETH, state UNDER
+                [
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        false,
+                        ['0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000000000000000000000000000000000009502f9000000000000000000000000000000000000000000000000000000000000000001'],
+                        [
+                            '0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+                            '0x0000000000000000000000000000000000000000000000000000000000000007',
+                            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x0000000000000000000000000000000000000000000000000000000005f5e100',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        ],
+                    ],
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        7,
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        0,
+                        web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        '100000000',
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        25,
+                        RatioState.UNDER,
+                    ]
+                ],
+                // cbBTC -> WETH, price 40 cbBTC/WETH, state OVER
+                [
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        false,
+                        ['0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000000000000000000000000000000000000ee6b28000000000000000000000000000000000000000000000000000000000000000000'],
+                        [
+                            '0x000000000000000000000000cbb7c0000ab88b473b1f5afd9ef808440eed33bf',
+                            '0x0000000000000000000000000000000000000000000000000000000000000007',
+                            '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x0000000000000000000000000000000000000000000000000000000005f5e100',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        ],
+                    ],
+                    [
+                        Strategies.MainnetIds.SPARK_COLLATERAL_SWITCH,
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        7,
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        0,
+                        web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        '100000000',
+                        web3Utils.toChecksumAddress(getAssetInfo('cbBTC', ChainId.Ethereum).address),
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        40,
+                        RatioState.OVER,
+                    ]
+                ],
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(sparkEncode.collateralSwitch(...actual)).to.eql(expected);
+                });
+            });
+        });
     });
     describe('When testing strategySubService.aaveV4Encode', () => {
         describe('leverageManagement()', () => {

package/esm/services/subDataService.d.ts

@@ -89,6 +89,13 @@ export declare const liquityLeverageManagementSubData: {
         targetRatio: number;
     };
 };
+export declare const liquityLeverageManagementSubDataWithoutSubProxy: {
+    encode(targetRatio: number, ratioState: RatioState): string[];
+    decode(subData: string[]): {
+        targetRatio: number;
+        ratioState: RatioState;
+    };
+};
 export declare const liquityCloseSubData: {
     encode(closeToAssetAddr: EthereumAddress, chainId?: ChainId, collAddr?: EthereumAddress, debtAddr?: EthereumAddress): string[];
     decode(subData: string[]): {
@@ -177,6 +184,14 @@ export declare const aaveV2LeverageManagementSubData: {
         targetRatio: number;
     };
 };
+export declare const aaveV2LeverageManagementSubDataWithoutSubProxy: {
+    encode(market: EthereumAddress, targetRatio: number, ratioState: RatioState): string[];
+    decode(subData: string[]): {
+        market: EthereumAddress;
+        targetRatio: number;
+        ratioState: RatioState;
+    };
+};
 /**
      ___           ___   ____    ____  _______    ____    ____  ____
     /   \         /   \  \   \  /   / |   ____|   \   \  /   / |___ \
@@ -320,6 +335,13 @@ export declare const compoundV2LeverageManagementSubData: {
         targetRatio: number;
     };
 };
+export declare const compoundV2LeverageManagementSubDataWithoutSubProxy: {
+    encode(targetRatio: number, ratioState: RatioState): string[];
+    decode(subData: string[]): {
+        targetRatio: number;
+        ratioState: RatioState;
+    };
+};
 /**
   ______   ______   .___  ___. .______      ____    ____  ____
  /      | /  __  \  |   \/   | |   _  \     \   \  /   / |___ \
@@ -334,10 +356,13 @@ export declare const compoundV3LeverageManagementSubData: {
         targetRatio: number;
     };
 };
-export declare const compoundV3L2LeverageManagementSubData: {
-    encode(market: EthereumAddress, baseToken: EthereumAddress, triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean, isEOA: boolean): string;
+export declare const compoundV3LeverageManagementSubDataWithoutSubProxy: {
+    encode(market: EthereumAddress, baseToken: EthereumAddress, targetRatio: number, ratioState: RatioState): string[];
     decode(subData: string[]): {
+        market: EthereumAddress;
+        baseToken: EthereumAddress;
         targetRatio: number;
+        ratioState: RatioState;
     };
 };
 export declare const compoundV3LeverageManagementOnPriceSubData: {
@@ -386,6 +411,14 @@ export declare const exchangeLimitOrderSubData: {
         amount: string;
     };
 };
+export declare const exchangeLimitOrderSubDataWithoutSubProxy: {
+    encode(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string): string[];
+    decode: (subData: string[], chainId: ChainId) => {
+        fromToken: string;
+        toToken: string;
+        amount: string;
+    };
+};
 /**
      _______..______      ___      .______       __  ___
     /       ||   _  \    /   \     |   _  \     |  |/  /
@@ -429,6 +462,17 @@ export declare const sparkLeverageManagementOnPriceSubData: {
         targetRatio: number;
     };
 };
+export declare const sparkCollateralSwitchSubData: {
+    encode(fromAsset: EthereumAddress, fromAssetId: number, toAsset: EthereumAddress, toAssetId: number, marketAddr: EthereumAddress, amountToSwitch: string, useOnBehalf?: boolean): string[];
+    decode(subData: string[]): {
+        fromAsset: EthereumAddress;
+        fromAssetId: number;
+        toAsset: EthereumAddress;
+        toAssetId: number;
+        marketAddr: EthereumAddress;
+        amountToSwitch: string;
+    };
+};
 /**
   ______ .______     ____    ____  __    __       _______. _______
  /      ||   _  \    \   \  /   / |  |  |  |     /       ||       \