@defisaver/automation-sdk 3.3.10-aave-v4-dev → 3.3.10-aave-v4-2-dev

package/esm/services/strategiesService.js

@@ -672,6 +672,29 @@ function parseSparkLeverageManagement(position, parseData) {
     _position.strategy.strategyId = Strategies.IdOverrides.LeverageManagement;
     return _position;
 }
+function parseSparkLeverageManagementOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.sparkQuotePriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.sparkLeverageManagementOnPriceSubData.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.specific = {
+        // subData
+        collAsset: subData.collAsset,
+        collAssetId: subData.collAssetId,
+        debtAsset: subData.debtAsset,
+        debtAssetId: subData.debtAssetId,
+        ratio: subData.targetRatio,
+        // triggerData
+        baseToken: triggerData.baseTokenAddr,
+        quoteToken: triggerData.quoteTokenAddr,
+        price: triggerData.price,
+        ratioState: triggerData.ratioState,
+    };
+    return _position;
+}
 function parseSparkCloseOnPrice(position, parseData) {
     const _position = cloneDeep(position);
     const { subStruct } = parseData.subscriptionEventData;
@@ -1045,6 +1068,8 @@ const parsingMethodsMapping = {
     [ProtocolIdentifiers.StrategiesAutomation.Spark]: {
         [Strategies.Identifiers.Repay]: parseSparkLeverageManagement,
         [Strategies.Identifiers.Boost]: parseSparkLeverageManagement,
+        [Strategies.Identifiers.RepayOnPrice]: parseSparkLeverageManagementOnPrice,
+        [Strategies.Identifiers.BoostOnPrice]: parseSparkLeverageManagementOnPrice,
         [Strategies.Identifiers.CloseOnPrice]: parseSparkCloseOnPrice,
     },
     [ProtocolIdentifiers.StrategiesAutomation.CrvUSD]: {

package/esm/services/strategySubService.d.ts

@@ -86,6 +86,19 @@ export declare const exchangeEncode: {
 };
 export declare const sparkEncode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string;
+    leverageManagementOnPrice(strategyOrBundleId: number, isBundle: boolean | undefined, triggerData: {
+        baseTokenAddr: EthereumAddress;
+        quoteTokenAddr: EthereumAddress;
+        price: number;
+        ratioState: RatioState;
+    }, subData: {
+        collAsset: EthereumAddress;
+        collAssetId: number;
+        debtAsset: EthereumAddress;
+        debtAssetId: number;
+        marketAddr: EthereumAddress;
+        targetRatio: number;
+    }): (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[])[];
     leverageManagementWithoutSubProxy(strategyOrBundleId: number, market: EthereumAddress, user: EthereumAddress, ratioState: RatioState, targetRatio: number, triggerRatio: number): (number | boolean | string[])[];
 };

package/esm/services/strategySubService.js

@@ -243,6 +243,13 @@ export const sparkEncode = {
         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);
+        const { baseTokenAddr, quoteTokenAddr, price, ratioState, } = triggerData;
+        const triggerDataEncoded = triggerService.sparkQuotePriceTrigger.encode(baseTokenAddr, quoteTokenAddr, price, ratioState);
+        return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+    },
     closeOnPriceGeneric(strategyOrBundleId, collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, user, stopLossPrice = 0, stopLossType = CloseToAssetType.DEBT, takeProfitPrice = 0, takeProfitType = CloseToAssetType.COLLATERAL) {
         const isBundle = true;
         const closeType = getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType);

package/esm/services/strategySubService.test.js

@@ -5,7 +5,7 @@ import { getAssetInfo, MAXUINT } from '@defisaver/tokens';
 import * as web3Utils from 'web3-utils';
 import { Bundles, ChainId, CloseToAssetType, OrderType, RatioState, Strategies } from '../types/enums';
 import '../configuration';
-import { aaveV2Encode, chickenBondsEncode, liquityEncode, makerEncode, aaveV3Encode, compoundV2Encode, compoundV3Encode, morphoAaveV2Encode, exchangeEncode, crvUSDEncode, compoundV3L2Encode, morphoBlueEncode, aaveV4Encode, } from './strategySubService';
+import { aaveV2Encode, chickenBondsEncode, liquityEncode, makerEncode, aaveV3Encode, compoundV2Encode, compoundV3Encode, morphoAaveV2Encode, exchangeEncode, crvUSDEncode, compoundV3L2Encode, morphoBlueEncode, sparkEncode, aaveV4Encode, } from './strategySubService';
 describe('Feature: strategySubService.ts', () => {
     describe('When testing strategySubService.makerEncode', () => {
         // @ts-ignore // TODO - this requires change in @defisaver/tokens
@@ -1453,6 +1453,139 @@ describe('Feature: strategySubService.ts', () => {
             });
         });
     });
+    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 = [
+                [
+                    [
+                        Bundles.MainnetIds.SPARK_REPAY_ON_PRICE,
+                        true,
+                        ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000003a352944000000000000000000000000000000000000000000000000000000000000000001'],
+                        ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                            '0x0000000000000000000000000000000000000000000000000000000000000001',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        ],
+                    ],
+                    [
+                        59,
+                        true,
+                        {
+                            baseTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                            quoteTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                            price: 2500,
+                            ratioState: RatioState.UNDER,
+                        },
+                        {
+                            collAsset: web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                            collAssetId: 0,
+                            debtAsset: web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                            debtAssetId: 1,
+                            marketAddr: web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                            targetRatio: 200,
+                        },
+                    ]
+                ],
+                [
+                    [
+                        Bundles.MainnetIds.SPARK_BOOST_ON_PRICE,
+                        true,
+                        ['0x0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c5990000000000000000000000006b175474e89094c44da98b954eedeac495271d0f00000000000000000000000000000000000000000000000000000417bce6c8000000000000000000000000000000000000000000000000000000000000000000'],
+                        [
+                            '0x0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599',
+                            '0x0000000000000000000000000000000000000000000000000000000000000002',
+                            '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f',
+                            '0x0000000000000000000000000000000000000000000000000000000000000004',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x00000000000000000000000000000000000000000000000022b1c8c1227a0000',
+                            '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        ]
+                    ],
+                    [
+                        60,
+                        true,
+                        {
+                            baseTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address),
+                            quoteTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                            price: 45000,
+                            ratioState: RatioState.OVER,
+                        },
+                        {
+                            collAsset: web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address),
+                            collAssetId: 2,
+                            debtAsset: web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                            debtAssetId: 4,
+                            marketAddr: web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                            targetRatio: 250,
+                        },
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(sparkEncode.leverageManagementOnPrice(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('closeOnPrice()', () => {
+            const examples = [
+                [
+                    [
+                        Bundles.MainnetIds.SPARK_CLOSE,
+                        true,
+                        ['0x0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c5990000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000000000000000000000000000000003a35294400000000000000000000000000000000000000000000000000000000574fbde6000'],
+                        [
+                            '0x0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599',
+                            '0x0000000000000000000000000000000000000000000000000000000000000002',
+                            '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f',
+                            '0x0000000000000000000000000000000000000000000000000000000000000004',
+                            '0x0000000000000000000000000000000000000000000000000000000000000005',
+                            '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                            '0x0000000000000000000000001234567890123456789012345678901234567890',
+                        ]
+                    ],
+                    [
+                        57,
+                        web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address),
+                        2,
+                        web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        4,
+                        web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        web3Utils.toChecksumAddress('0x1234567890123456789012345678901234567890'),
+                        40000,
+                        CloseToAssetType.DEBT,
+                        60000,
+                        CloseToAssetType.COLLATERAL,
+                    ]
+                ],
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(sparkEncode.closeOnPriceGeneric(...actual)).to.eql(expected);
+                });
+            });
+        });
+    });
     describe('When testing strategySubService.aaveV4Encode', () => {
         describe('leverageManagement()', () => {
             const examples = [

package/esm/services/subDataService.d.ts

@@ -418,6 +418,17 @@ export declare const sparkCloseGenericSubData: {
         owner: EthereumAddress;
     };
 };
+export declare const sparkLeverageManagementOnPriceSubData: {
+    encode(collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number, marketAddr: EthereumAddress, targetRatio: number): string[];
+    decode(subData: string[]): {
+        collAsset: EthereumAddress;
+        collAssetId: number;
+        debtAsset: EthereumAddress;
+        debtAssetId: number;
+        marketAddr: EthereumAddress;
+        targetRatio: number;
+    };
+};
 /**
   ______ .______     ____    ____  __    __       _______. _______
  /      ||   _  \    \   \  /   / |  |  |  |     /       ||       \

package/esm/services/subDataService.js

@@ -943,6 +943,30 @@ export const sparkCloseGenericSubData = {
         };
     },
 };
+export const sparkLeverageManagementOnPriceSubData = {
+    encode(collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio) {
+        const encodedColl = AbiCoder.encodeParameter('address', collAsset);
+        const encodedCollId = AbiCoder.encodeParameter('uint16', collAssetId);
+        const encodedDebt = AbiCoder.encodeParameter('address', debtAsset);
+        const encodedDebtId = AbiCoder.encodeParameter('uint16', debtAssetId);
+        const encodedMarket = AbiCoder.encodeParameter('address', marketAddr);
+        const encodedTargetRatio = AbiCoder.encodeParameter('uint256', ratioPercentageToWei(targetRatio));
+        const useOnBehalfEncoded = AbiCoder.encodeParameter('bool', false);
+        return [encodedColl, encodedCollId, encodedDebt, encodedDebtId, encodedMarket, encodedTargetRatio, useOnBehalfEncoded];
+    },
+    decode(subData) {
+        const collAsset = AbiCoder.decodeParameter('address', subData[0]);
+        const collAssetId = Number(AbiCoder.decodeParameter('uint16', subData[1]));
+        const debtAsset = AbiCoder.decodeParameter('address', subData[2]);
+        const debtAssetId = Number(AbiCoder.decodeParameter('uint16', subData[3]));
+        const marketAddr = AbiCoder.decodeParameter('address', subData[4]);
+        const weiRatio = AbiCoder.decodeParameter('uint256', subData[5]);
+        const targetRatio = weiToRatioPercentage(weiRatio);
+        return {
+            collAsset, collAssetId, debtAsset, debtAssetId, marketAddr, targetRatio,
+        };
+    },
+};
 /**
   ______ .______     ____    ____  __    __       _______. _______
  /      ||   _  \    \   \  /   / |  |  |  |     /       ||       \

package/esm/services/subDataService.test.js

@@ -2061,6 +2061,63 @@ describe('Feature: subDataService.ts', () => {
             });
         });
     });
+    describe('When testing subDataService.sparkLeverageManagementOnPriceSubData', () => {
+        describe('encode()', () => {
+            const examples = [
+                [
+                    [
+                        '0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                        '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        '0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+                        '0x0000000000000000000000000000000000000000000000000000000000000001',
+                        '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                        '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+                        '0x0000000000000000000000000000000000000000000000000000000000000000',
+                    ],
+                    [
+                        web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        0,
+                        web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        1,
+                        web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        200,
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(subDataService.sparkLeverageManagementOnPriceSubData.encode(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('decode()', () => {
+            const examples = [
+                [
+                    {
+                        collAsset: web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address),
+                        collAssetId: 2,
+                        debtAsset: web3Utils.toChecksumAddress(getAssetInfo('DAI', ChainId.Ethereum).address),
+                        debtAssetId: 4,
+                        marketAddr: web3Utils.toChecksumAddress('0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE'),
+                        targetRatio: 175
+                    },
+                    [
+                        '0x0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599',
+                        '0x0000000000000000000000000000000000000000000000000000000000000002',
+                        '0x0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f',
+                        '0x0000000000000000000000000000000000000000000000000000000000000004',
+                        '0x00000000000000000000000002c3ea4e34c0cbd694d2adfa2c690eecbc1793ee',
+                        '0x00000000000000000000000000000000000000000000000018493fba64ef0000'
+                    ]
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(subDataService.sparkLeverageManagementOnPriceSubData.decode(actual)).to.eql(expected);
+                });
+            });
+        });
+    });
     describe('When testing subDataService.aaveV4LeverageManagementSubData', () => {
         describe('encode()', () => {
             const examples = [

package/esm/services/triggerService.d.ts

@@ -285,6 +285,15 @@ export declare const morphoBluePriceRangeTrigger: {
         upperPrice: string;
     };
 };
+export declare const sparkQuotePriceTrigger: {
+    encode(baseTokenAddr: EthereumAddress, quoteTokenAddr: EthereumAddress, price: number, ratioState: RatioState): string[];
+    decode(triggerData: string[]): {
+        baseTokenAddr: string;
+        quoteTokenAddr: string;
+        price: string;
+        ratioState: number;
+    };
+};
 export declare const aaveV4RatioTrigger: {
     encode(owner: EthereumAddress, spoke: EthereumAddress, ratioPercentage: number, ratioState: RatioState): string[];
     decode(triggerData: string[]): {

package/esm/services/triggerService.js

@@ -518,6 +518,21 @@ export const morphoBluePriceRangeTrigger = {
         };
     },
 };
+export const sparkQuotePriceTrigger = {
+    encode(baseTokenAddr, quoteTokenAddr, price, ratioState) {
+        const _price = new Dec(price.toString()).mul(1e8).floor().toString();
+        return [AbiCoder.encodeParameters(['address', 'address', 'uint256', 'uint8'], [baseTokenAddr, quoteTokenAddr, _price, ratioState])];
+    },
+    decode(triggerData) {
+        const decodedData = AbiCoder.decodeParameters(['address', 'address', 'uint256', 'uint8'], triggerData[0]);
+        return {
+            baseTokenAddr: decodedData[0],
+            quoteTokenAddr: decodedData[1],
+            price: new Dec(decodedData[2]).div(1e8).toString(),
+            ratioState: Number(decodedData[3]),
+        };
+    },
+};
 export const aaveV4RatioTrigger = {
     encode(owner, spoke, ratioPercentage, ratioState) {
         const ratioWei = ratioPercentageToWei(ratioPercentage);

package/esm/services/triggerService.test.js

@@ -3,7 +3,7 @@ import { getAssetInfo, MAXUINT } from '@defisaver/tokens';
 import * as web3Utils from 'web3-utils';
 import { ChainId, OrderType, RatioState } from '../types/enums';
 import '../configuration';
-import { aaveV2RatioTrigger, aaveV3QuotePriceTrigger, aaveV3QuotePriceWithMaximumGasPriceTrigger, aaveV3RatioTrigger, cBondsRebondTrigger, chainlinkPriceTrigger, compoundV2RatioTrigger, compoundV3RatioTrigger, compoundV3PriceTrigger, curveUsdBorrowRateTrigger, curveUsdSoftLiquidationTrigger, exchangeOffchainPriceTrigger, exchangeTimestampTrigger, liquityDebtInFrontTrigger, makerRatioTrigger, morphoAaveV2RatioTrigger, sparkRatioTrigger, trailingStopTrigger, liquityDebtInFrontWithLimitTrigger, crvUSDRatioTrigger, morphoBlueRatioTrigger, crvUsdHealthRatioTrigger, liquityV2DebtInFrontTrigger, liquityV2AdjustTimeTrigger, compoundV3PriceRangeTrigger, aaveV3QuotePriceRangeTrigger, morphoBluePriceRangeTrigger, aaveV4RatioTrigger, aaveV4QuotePriceTrigger, aaveV4QuotePriceRangeTrigger, } from './triggerService';
+import { aaveV2RatioTrigger, aaveV3QuotePriceTrigger, aaveV3QuotePriceWithMaximumGasPriceTrigger, aaveV3RatioTrigger, cBondsRebondTrigger, chainlinkPriceTrigger, compoundV2RatioTrigger, compoundV3RatioTrigger, compoundV3PriceTrigger, curveUsdBorrowRateTrigger, curveUsdSoftLiquidationTrigger, exchangeOffchainPriceTrigger, exchangeTimestampTrigger, liquityDebtInFrontTrigger, makerRatioTrigger, morphoAaveV2RatioTrigger, sparkRatioTrigger, trailingStopTrigger, liquityDebtInFrontWithLimitTrigger, crvUSDRatioTrigger, morphoBlueRatioTrigger, crvUsdHealthRatioTrigger, liquityV2DebtInFrontTrigger, liquityV2AdjustTimeTrigger, compoundV3PriceRangeTrigger, aaveV3QuotePriceRangeTrigger, morphoBluePriceRangeTrigger, sparkQuotePriceTrigger, aaveV4RatioTrigger, aaveV4QuotePriceTrigger, aaveV4QuotePriceRangeTrigger, } from './triggerService';
 describe('Feature: triggerService.ts', () => {
     describe('When testing triggerService.chainlinkPriceTrigger', () => {
         describe('encode()', () => {
@@ -1243,4 +1243,50 @@ describe('Feature: triggerService.ts', () => {
             });
         });
     });
+    describe('When testing triggerService.sparkQuotePriceTrigger', () => {
+        describe('encode()', () => {
+            const examples = [
+                [
+                    ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000003a352944000000000000000000000000000000000000000000000000000000000000000001'],
+                    [web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address), web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address), 2500, RatioState.UNDER]
+                ],
+                [
+                    ['0x000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c5990000000000000000000000000000000000000000000000000000000000000c1c0000000000000000000000000000000000000000000000000000000000000000'],
+                    [web3Utils.toChecksumAddress(getAssetInfo('USDT', ChainId.Ethereum).address), web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address), 0.000031, RatioState.OVER]
+                ],
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${actual} should return expected value: ${expected}`, () => {
+                    expect(sparkQuotePriceTrigger.encode(...actual)).to.eql(expected);
+                });
+            });
+        });
+        describe('decode()', () => {
+            const examples = [
+                [
+                    {
+                        baseTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('WETH', ChainId.Ethereum).address),
+                        quoteTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('USDC', ChainId.Ethereum).address),
+                        price: '2500',
+                        ratioState: RatioState.UNDER
+                    },
+                    ['0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000003a352944000000000000000000000000000000000000000000000000000000000000000001']
+                ],
+                [
+                    {
+                        baseTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('USDT', ChainId.Ethereum).address),
+                        quoteTokenAddr: web3Utils.toChecksumAddress(getAssetInfo('WBTC', ChainId.Ethereum).address),
+                        price: '0.000031',
+                        ratioState: RatioState.OVER
+                    },
+                    ['0x000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c5990000000000000000000000000000000000000000000000000000000000000c1c0000000000000000000000000000000000000000000000000000000000000000']
+                ]
+            ];
+            examples.forEach(([expected, actual]) => {
+                it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
+                    expect(sparkQuotePriceTrigger.decode(actual)).to.eql(expected);
+                });
+            });
+        });
+    });
 });

package/esm/types/enums.d.ts

@@ -88,7 +88,8 @@ export declare namespace Strategies {
         CURVEUSD_PAYBACK = 92,
         LIQUITY_V2_PAYBACK = 113,
         AAVE_V3_COLLATERAL_SWITCH = 135,
-        AAVE_V4_COLLATERAL_SWITCH = 151
+        AAVE_V4_COLLATERAL_SWITCH = 154,
+        AAVE_V4_COLLATERAL_SWITCH_EOA = 165
     }
     enum OptimismIds {
         EXCHANGE_DCA = 8,
@@ -135,7 +136,8 @@ export declare namespace Strategies {
         RepayOnPrice = "repay-on-price",
         EoaBoostOnPrice = "eoa-boost-on-price",
         EoaRepayOnPrice = "eoa-repay-on-price",
-        CollateralSwitch = "collateral-switch"
+        CollateralSwitch = "collateral-switch",
+        EoaCollateralSwitch = "eoa-collateral-switch"
     }
     enum IdOverrides {
         TakeProfit = "take-profit",
@@ -210,16 +212,18 @@ export declare namespace Bundles {
         AAVE_V3_EOA_CLOSE = 56,
         SPARK_CLOSE = 57,
         MORPHO_BLUE_CLOSE = 58,
-        AAVE_V4_REPAY = 59,
-        AAVE_V4_BOOST = 60,
-        AAVE_V4_REPAY_ON_PRICE = 61,
-        AAVE_V4_BOOST_ON_PRICE = 62,
-        AAVE_V4_CLOSE = 63,
-        AAVE_V4_EOA_REPAY = 64,
-        AAVE_V4_EOA_BOOST = 65,
-        AAVE_V4_EOA_REPAY_ON_PRICE = 66,
-        AAVE_V4_EOA_BOOST_ON_PRICE = 67,
-        AAVE_V4_EOA_CLOSE = 68
+        SPARK_REPAY_ON_PRICE = 59,
+        SPARK_BOOST_ON_PRICE = 60,
+        AAVE_V4_REPAY = 61,
+        AAVE_V4_BOOST = 62,
+        AAVE_V4_REPAY_ON_PRICE = 63,
+        AAVE_V4_BOOST_ON_PRICE = 64,
+        AAVE_V4_CLOSE = 65,
+        AAVE_V4_EOA_REPAY = 66,
+        AAVE_V4_EOA_BOOST = 67,
+        AAVE_V4_EOA_REPAY_ON_PRICE = 68,
+        AAVE_V4_EOA_BOOST_ON_PRICE = 69,
+        AAVE_V4_EOA_CLOSE = 70
     }
     enum OptimismIds {
         AAVE_V3_REPAY = 0,

package/esm/types/enums.js

@@ -101,7 +101,8 @@ export var Strategies;
         MainnetIds[MainnetIds["CURVEUSD_PAYBACK"] = 92] = "CURVEUSD_PAYBACK";
         MainnetIds[MainnetIds["LIQUITY_V2_PAYBACK"] = 113] = "LIQUITY_V2_PAYBACK";
         MainnetIds[MainnetIds["AAVE_V3_COLLATERAL_SWITCH"] = 135] = "AAVE_V3_COLLATERAL_SWITCH";
-        MainnetIds[MainnetIds["AAVE_V4_COLLATERAL_SWITCH"] = 151] = "AAVE_V4_COLLATERAL_SWITCH";
+        MainnetIds[MainnetIds["AAVE_V4_COLLATERAL_SWITCH"] = 154] = "AAVE_V4_COLLATERAL_SWITCH";
+        MainnetIds[MainnetIds["AAVE_V4_COLLATERAL_SWITCH_EOA"] = 165] = "AAVE_V4_COLLATERAL_SWITCH_EOA";
     })(MainnetIds = Strategies.MainnetIds || (Strategies.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {
@@ -153,6 +154,7 @@ export var Strategies;
         Identifiers["EoaBoostOnPrice"] = "eoa-boost-on-price";
         Identifiers["EoaRepayOnPrice"] = "eoa-repay-on-price";
         Identifiers["CollateralSwitch"] = "collateral-switch";
+        Identifiers["EoaCollateralSwitch"] = "eoa-collateral-switch";
     })(Identifiers = Strategies.Identifiers || (Strategies.Identifiers = {}));
     let IdOverrides;
     (function (IdOverrides) {
@@ -230,16 +232,18 @@ export var Bundles;
         MainnetIds[MainnetIds["AAVE_V3_EOA_CLOSE"] = 56] = "AAVE_V3_EOA_CLOSE";
         MainnetIds[MainnetIds["SPARK_CLOSE"] = 57] = "SPARK_CLOSE";
         MainnetIds[MainnetIds["MORPHO_BLUE_CLOSE"] = 58] = "MORPHO_BLUE_CLOSE";
-        MainnetIds[MainnetIds["AAVE_V4_REPAY"] = 59] = "AAVE_V4_REPAY";
-        MainnetIds[MainnetIds["AAVE_V4_BOOST"] = 60] = "AAVE_V4_BOOST";
-        MainnetIds[MainnetIds["AAVE_V4_REPAY_ON_PRICE"] = 61] = "AAVE_V4_REPAY_ON_PRICE";
-        MainnetIds[MainnetIds["AAVE_V4_BOOST_ON_PRICE"] = 62] = "AAVE_V4_BOOST_ON_PRICE";
-        MainnetIds[MainnetIds["AAVE_V4_CLOSE"] = 63] = "AAVE_V4_CLOSE";
-        MainnetIds[MainnetIds["AAVE_V4_EOA_REPAY"] = 64] = "AAVE_V4_EOA_REPAY";
-        MainnetIds[MainnetIds["AAVE_V4_EOA_BOOST"] = 65] = "AAVE_V4_EOA_BOOST";
-        MainnetIds[MainnetIds["AAVE_V4_EOA_REPAY_ON_PRICE"] = 66] = "AAVE_V4_EOA_REPAY_ON_PRICE";
-        MainnetIds[MainnetIds["AAVE_V4_EOA_BOOST_ON_PRICE"] = 67] = "AAVE_V4_EOA_BOOST_ON_PRICE";
-        MainnetIds[MainnetIds["AAVE_V4_EOA_CLOSE"] = 68] = "AAVE_V4_EOA_CLOSE";
+        MainnetIds[MainnetIds["SPARK_REPAY_ON_PRICE"] = 59] = "SPARK_REPAY_ON_PRICE";
+        MainnetIds[MainnetIds["SPARK_BOOST_ON_PRICE"] = 60] = "SPARK_BOOST_ON_PRICE";
+        MainnetIds[MainnetIds["AAVE_V4_REPAY"] = 61] = "AAVE_V4_REPAY";
+        MainnetIds[MainnetIds["AAVE_V4_BOOST"] = 62] = "AAVE_V4_BOOST";
+        MainnetIds[MainnetIds["AAVE_V4_REPAY_ON_PRICE"] = 63] = "AAVE_V4_REPAY_ON_PRICE";
+        MainnetIds[MainnetIds["AAVE_V4_BOOST_ON_PRICE"] = 64] = "AAVE_V4_BOOST_ON_PRICE";
+        MainnetIds[MainnetIds["AAVE_V4_CLOSE"] = 65] = "AAVE_V4_CLOSE";
+        MainnetIds[MainnetIds["AAVE_V4_EOA_REPAY"] = 66] = "AAVE_V4_EOA_REPAY";
+        MainnetIds[MainnetIds["AAVE_V4_EOA_BOOST"] = 67] = "AAVE_V4_EOA_BOOST";
+        MainnetIds[MainnetIds["AAVE_V4_EOA_REPAY_ON_PRICE"] = 68] = "AAVE_V4_EOA_REPAY_ON_PRICE";
+        MainnetIds[MainnetIds["AAVE_V4_EOA_BOOST_ON_PRICE"] = 69] = "AAVE_V4_EOA_BOOST_ON_PRICE";
+        MainnetIds[MainnetIds["AAVE_V4_EOA_CLOSE"] = 70] = "AAVE_V4_EOA_CLOSE";
     })(MainnetIds = Bundles.MainnetIds || (Bundles.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {

package/esm/types/index.d.ts

@@ -197,6 +197,17 @@ export declare namespace Position {
             stopLossType: CloseToAssetType | undefined;
             takeProfitType: CloseToAssetType | undefined;
         }
+        interface SparkOnPrice extends Base {
+            collAsset: EthereumAddress;
+            collAssetId: number;
+            debtAsset: EthereumAddress;
+            debtAssetId: number;
+            baseToken: EthereumAddress;
+            quoteToken: EthereumAddress;
+            price: string;
+            ratioState: RatioState;
+            ratio: number;
+        }
         interface CloseBase extends Base {
             stopLossPrice: string;
             takeProfitPrice: string;
@@ -219,7 +230,7 @@ export declare namespace Position {
             debtAssetId: number;
         }
     }
-    type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave | Specific.BoostOnPriceAave | Specific.CloseOnPriceWithMaximumGasPriceAave | Specific.DebtInFrontRepay | Specific.LeverageManagementCrvUSD | Specific.CloseOnPriceLiquityV2 | Specific.BoostOnPriceMorpho | Specific.BoostOnPriceLiquityV2 | Specific.PaybackLiquityV2 | Specific.CompoundV3LeverageManagementOnPrice | Specific.CompoundV3CloseOnPrice | Specific.AaveV3CloseOnPriceGeneric | Specific.AaveV4LeverageManagementOnPrice | Specific.AaveV4CloseOnPrice;
+    type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave | Specific.BoostOnPriceAave | Specific.CloseOnPriceWithMaximumGasPriceAave | Specific.DebtInFrontRepay | Specific.LeverageManagementCrvUSD | Specific.CloseOnPriceLiquityV2 | Specific.BoostOnPriceMorpho | Specific.BoostOnPriceLiquityV2 | Specific.PaybackLiquityV2 | Specific.CompoundV3LeverageManagementOnPrice | Specific.CompoundV3CloseOnPrice | Specific.AaveV3CloseOnPriceGeneric | Specific.AaveV4LeverageManagementOnPrice | Specific.AaveV4CloseOnPrice | Specific.SparkOnPrice;
     interface Automated {
         chainId: ChainId;
         positionId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.10-aave-v4-dev",
+  "version": "3.3.10-aave-v4-2-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -23,7 +23,7 @@
   "repository": "https://github.com/defisaver/automation-sdk",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/sdk": "^1.3.15",
+    "@defisaver/sdk": "1.3.18-aave-v4-dev",
     "@defisaver/tokens": "^1.6.19",
     "@ethersproject/address": "^5.0.10",
     "@ethersproject/solidity": "^5.0.9",

package/src/constants/index.ts

@@ -128,6 +128,11 @@ export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
     strategyId: Strategies.Identifiers.CollateralSwitch,
     protocol: PROTOCOLS.AaveV4,
   },
+  [Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA]: {
+    strategyOrBundleId: Strategies.MainnetIds.AAVE_V4_COLLATERAL_SWITCH_EOA,
+    strategyId: Strategies.Identifiers.EoaCollateralSwitch,
+    protocol: PROTOCOLS.AaveV4,
+  },
 };
 
 export const OPTIMISM_STRATEGIES_INFO: OptimismStrategiesInfo = {
@@ -501,6 +506,16 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.CloseOnPrice,
     protocol: PROTOCOLS.MorphoBlue,
   },
+  [Bundles.MainnetIds.SPARK_REPAY_ON_PRICE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_REPAY_ON_PRICE,
+    strategyId: Strategies.Identifiers.RepayOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
+  [Bundles.MainnetIds.SPARK_BOOST_ON_PRICE]: {
+    strategyOrBundleId: Bundles.MainnetIds.SPARK_BOOST_ON_PRICE,
+    strategyId: Strategies.Identifiers.BoostOnPrice,
+    protocol: PROTOCOLS.Spark,
+  },
   [Bundles.MainnetIds.AAVE_V4_REPAY]: {
     strategyOrBundleId: Bundles.MainnetIds.AAVE_V4_REPAY,
     strategyId: Strategies.Identifiers.Repay,