@defisaver/automation-sdk 2.0.6 → 2.0.8

package/.env.dev

@@ -0,0 +1,5 @@
+# Used for testing
+RPC_1=
+RPC_10=
+RPC_8453=
+RPC_42161=

package/.tests.sh

@@ -0,0 +1,3 @@
+if [ -z "$1" ]; then mocha "./src/**/*.test.ts" --require ts-node/register --extension ts;
+else mocha "./src/**/${1}.test.ts" --require ts-node/register --extension ts;
+fi

package/README.md

@@ -33,4 +33,6 @@ const subscriptions = await ethereumStrategies.getSubscriptionsFor(
   - `./src/services/subDataService.ts`
   - `./src/services/triggerService.ts`
 - Write parsing for the strategy in `./src/services/strategeiesService.ts` and add assign it to `const parsingMethodsMapping`
-- Test it out!
+- Write tests for each method
+- Run tests with `yarn test` or `yarn test fileName` for a specific file (e.g. `yarn test utils`)
+- Congrats! 🥳

package/esm/automation/private/LegacyProtocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/automation/private/LegacyProtocol.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const enums_1 = require("../../types/enums");
+const LegacyProtocol_1 = __importDefault(require("./LegacyProtocol"));
+describe('Feature: LegacyProtocol.ts', () => {
+    describe('When testing class LegacyProtocol', () => {
+        const exampleProtocol = new LegacyProtocol_1.default({ id: enums_1.ProtocolIdentifiers.LegacyAutomation.MakerDAO });
+        const examples = [
+            [exampleProtocol.id, 'MakerDAO'],
+            [exampleProtocol.name, 'MakerDAO'],
+            [exampleProtocol.slug, 'makerdao'],
+            [exampleProtocol.version, ''],
+            [exampleProtocol.fullName, 'MakerDAO'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)(actual).to.equal(expected);
+            });
+        });
+    });
+});

package/esm/automation/private/Protocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/automation/private/Protocol.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const enums_1 = require("../../types/enums");
+const Protocol_1 = __importDefault(require("./Protocol"));
+describe('Feature: Protocol.ts', () => {
+    describe('When testing class Protocol', () => {
+        const exampleProtocol = new Protocol_1.default({ id: enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV3 });
+        const examples = [
+            [exampleProtocol.id, 'Aave__V3'],
+            [exampleProtocol.name, 'Aave'],
+            [exampleProtocol.slug, 'aave'],
+            [exampleProtocol.version, 'V3'],
+            [exampleProtocol.fullName, 'Aave V3'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)(actual).to.equal(expected);
+            });
+        });
+    });
+});

package/esm/constants/index.js

@@ -85,6 +85,11 @@ exports.MAINNET_STRATEGIES_INFO = {
         strategyId: enums_1.Strategies.Identifiers.SavingsDsrSupply,
         protocol: exports.PROTOCOLS.Liquity,
     },
+    [enums_1.Strategies.MainnetIds.LIQUITY_DEBT_IN_FRONT_REPAY]: {
+        strategyOrBundleId: enums_1.Strategies.MainnetIds.LIQUITY_DEBT_IN_FRONT_REPAY,
+        strategyId: enums_1.Strategies.Identifiers.DebtInFrontRepay,
+        protocol: exports.PROTOCOLS.Liquity,
+    },
 };
 exports.OPTIMISM_STRATEGIES_INFO = {
     [enums_1.Strategies.OptimismIds.EXCHANGE_DCA]: {

package/esm/services/contractService.d.ts

@@ -1,11 +1,12 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
-import type { Contract } from '../types';
+import type { Contract, EthereumAddress } from '../types';
 import type { BaseContract } from '../types/contracts/generated/types';
-import type { Legacy_AuthCheck, SubStorage, UniMulticall } from '../types/contracts/generated';
+import type { Legacy_AuthCheck, SubStorage, UniMulticall, Erc20 } from '../types/contracts/generated';
 import { ChainId } from '../types/enums';
 export declare function getAbiItem(abi: AbiItem[], itemName: string): AbiItem;
 export declare function makeUniMulticallContract(web3: Web3, chainId: ChainId): Contract.WithMeta<UniMulticall>;
 export declare function makeSubStorageContract(web3: Web3, chainId: ChainId): Contract.WithMeta<SubStorage>;
 export declare function makeAuthCheckerContract(web3: Web3, chainId: ChainId): Contract.WithMeta<Legacy_AuthCheck>;
 export declare function makeLegacySubscriptionContract<T extends BaseContract>(web3: Web3, contractJson: Contract.Json): Contract.WithMeta<T>;
+export declare function makeErc20Contract(web3: Web3, tokenAddress: EthereumAddress, chainId: ChainId): Contract.WithMeta<Erc20>;

package/esm/services/contractService.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLegacySubscriptionContract = exports.makeAuthCheckerContract = exports.makeSubStorageContract = exports.makeUniMulticallContract = exports.getAbiItem = void 0;
+exports.makeErc20Contract = exports.makeLegacySubscriptionContract = exports.makeAuthCheckerContract = exports.makeSubStorageContract = exports.makeUniMulticallContract = exports.getAbiItem = void 0;
 const abis_1 = require("../abis");
 const utils_1 = require("./utils");
 const enums_1 = require("../types/enums");
@@ -46,3 +46,9 @@ function makeLegacySubscriptionContract(web3, contractJson) {
     return makeContract(web3, contractJson, enums_1.ChainId.Ethereum);
 }
 exports.makeLegacySubscriptionContract = makeLegacySubscriptionContract;
+function makeErc20Contract(web3, tokenAddress, chainId) {
+    return makeContract(web3, Object.assign(Object.assign({}, abis_1.Erc20Json), { networks: {
+            [chainId]: { address: tokenAddress },
+        } }), chainId);
+}
+exports.makeErc20Contract = makeErc20Contract;

package/esm/services/ethereumService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/services/ethereumService.test.js

@@ -0,0 +1,241 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_1 = __importDefault(require("web3"));
+const chai_1 = require("chai");
+const tokens_1 = require("@defisaver/tokens");
+const enums_1 = require("../types/enums");
+const ethereumService_1 = require("./ethereumService");
+const contractService_1 = require("./contractService");
+require('dotenv').config({ path: '.env' });
+const Web3_1 = new web3_1.default(process.env.RPC_1);
+const Web3_10 = new web3_1.default(process.env.RPC_10);
+const Web3_42161 = new web3_1.default(process.env.RPC_42161);
+describe('Feature: ethereumService.ts', () => {
+    describe('When testing ethereumService.multicall', () => {
+        const examples = [
+            [
+                [{ 0: 'Wrapped Ether', '__length__': 1 }, { 0: '18', '__length__': 1 }],
+                [
+                    Web3_1,
+                    enums_1.ChainId.Ethereum,
+                    [
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'name', 'outputs': [{ 'name': '', 'type': 'string' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            params: [],
+                        },
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'decimals', 'outputs': [{ 'name': '', 'type': 'uint8' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                            params: [],
+                        }
+                    ],
+                    'latest',
+                ]
+            ],
+            [
+                [{ 0: 'Wrapped Ether', '__length__': 1 }, { 0: '18', '__length__': 1 }],
+                [
+                    Web3_10,
+                    enums_1.ChainId.Optimism,
+                    [
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'name', 'outputs': [{ 'name': '', 'type': 'string' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0x4200000000000000000000000000000000000006',
+                            params: [],
+                        },
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'decimals', 'outputs': [{ 'name': '', 'type': 'uint8' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0x4200000000000000000000000000000000000006',
+                            params: [],
+                        }
+                    ],
+                    'latest',
+                ]
+            ],
+            [
+                [{ 0: 'Wrapped Ether', '__length__': 1 }, { 0: '18', '__length__': 1 }],
+                [
+                    Web3_42161,
+                    enums_1.ChainId.Arbitrum,
+                    [
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'name', 'outputs': [{ 'name': '', 'type': 'string' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+                            params: [],
+                        },
+                        {
+                            abiItem: { 'constant': true, 'inputs': [], 'name': 'decimals', 'outputs': [{ 'name': '', 'type': 'uint8' }], 'payable': false, 'stateMutability': 'view', 'type': 'function' },
+                            target: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+                            params: [],
+                        }
+                    ],
+                    'latest',
+                ]
+            ],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                (0, chai_1.expect)(yield (0, ethereumService_1.multicall)(...actual)).to.eql(expected);
+            }));
+        });
+    });
+    describe('When testing ethereumService.getEventsFromContract', () => {
+        const examples = [
+            [
+                [
+                    {
+                        'address': '0x5f98805A4E8be255a32880FDeC7F6728C6568bA0',
+                        'blockHash': '0xb92cab2569456dbfbdb853d2c67d72c9a7580543dbcb55d483a77322b40755a4',
+                        'blockNumber': 15166163,
+                        'event': 'Transfer',
+                        'id': 'log_e2258e3a',
+                        'logIndex': 385,
+                        'raw': {
+                            'data': '0x0000000000000000000000000000000000000000000001b58c2186829983fca9',
+                            'topics': [
+                                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                                '0x000000000000000000000000ea57dc30959eb17c506e4da095fa9181f3e0ac6d',
+                                '0x0000000000000000000000009ccf93089cb14f94baeb8822f8ceffd91bd71649',
+                            ],
+                        },
+                        'removed': false,
+                        'returnValues': {
+                            '0': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            '1': '0x9cCf93089cb14F94BAeB8822F8CeFfd91Bd71649',
+                            '2': '8071324659946094853289',
+                            'from': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            'to': '0x9cCf93089cb14F94BAeB8822F8CeFfd91Bd71649',
+                            'value': '8071324659946094853289',
+                        },
+                        'signature': '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                        'transactionHash': '0x95b28d8f71719c219e09b428e6ff781d717088784fbf63681446da13de6b0c4a',
+                        'transactionIndex': 187,
+                    },
+                ],
+                [
+                    (0, contractService_1.makeErc20Contract)(Web3_1, (0, tokens_1.getAssetInfo)('LUSD').address, enums_1.ChainId.Ethereum),
+                    null,
+                    'Transfer',
+                    {
+                        fromBlock: 15166163,
+                        toBlock: 15166163,
+                        filter: {
+                            from: '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            to: '0x9cCf93089cb14F94BAeB8822F8CeFfd91Bd71649',
+                        }
+                    },
+                ]
+            ],
+            [
+                [
+                    {
+                        'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
+                        'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
+                        'blockNumber': 5353002,
+                        'event': 'Transfer',
+                        'id': 'log_f49645b8',
+                        'logIndex': 1,
+                        'raw': {
+                            'data': '0x000000000000000000000000000000000000000000000001158e460913d00000',
+                            'topics': [
+                                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                                '0x000000000000000000000000ea57dc30959eb17c506e4da095fa9181f3e0ac6d',
+                                '0x00000000000000000000000013a22f1bba428eaaf56960530ec11118da916c11',
+                            ],
+                        },
+                        'removed': false,
+                        'returnValues': {
+                            '0': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            '1': '0x13A22f1bBa428eaAf56960530Ec11118DA916C11',
+                            '2': '20000000000000000000',
+                            'from': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            'to': '0x13A22f1bBa428eaAf56960530Ec11118DA916C11',
+                            'value': '20000000000000000000',
+                        },
+                        'signature': '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                        'transactionHash': '0x37c886a97c938747299c0f6b3e4591304bdd47a938df7c8146454d6fee5a6501',
+                        'transactionIndex': 0,
+                    },
+                ],
+                [
+                    (0, contractService_1.makeErc20Contract)(Web3_10, (0, tokens_1.getAssetInfo)('DAI', enums_1.ChainId.Optimism).address, enums_1.ChainId.Optimism),
+                    null,
+                    'Transfer',
+                    {
+                        fromBlock: 5353002,
+                        toBlock: 5353002,
+                        filter: {
+                            from: '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            to: '0x13A22f1bBa428eaAf56960530Ec11118DA916C11',
+                        }
+                    },
+                ]
+            ],
+            [
+                [
+                    {
+                        'address': '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
+                        'blockHash': '0xacb0213af63b4c17c436f084a96d1ac385641a59a9a4cf014ae3337cbe545aa7',
+                        'blockNumber': 5353002,
+                        'event': 'Transfer',
+                        'id': 'log_f49645b8',
+                        'logIndex': 1,
+                        'raw': {
+                            'data': '0x000000000000000000000000000000000000000000000001158e460913d00000',
+                            'topics': [
+                                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                                '0x000000000000000000000000ea57dc30959eb17c506e4da095fa9181f3e0ac6d',
+                                '0x00000000000000000000000013a22f1bba428eaaf56960530ec11118da916c11',
+                            ],
+                        },
+                        'removed': false,
+                        'returnValues': {
+                            '0': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            '1': '0x13A22f1bBa428eaAf56960530Ec11118DA916C11',
+                            '2': '20000000000000000000',
+                            'from': '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            'to': '0x13A22f1bBa428eaAf56960530Ec11118DA916C11',
+                            'value': '20000000000000000000',
+                        },
+                        'signature': '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                        'transactionHash': '0x37c886a97c938747299c0f6b3e4591304bdd47a938df7c8146454d6fee5a6501',
+                        'transactionIndex': 0,
+                    },
+                ],
+                [
+                    (0, contractService_1.makeErc20Contract)(Web3_10, (0, tokens_1.getAssetInfo)('DAI', enums_1.ChainId.Arbitrum).address, enums_1.ChainId.Arbitrum),
+                    null,
+                    'Transfer',
+                    {
+                        fromBlock: 5353002,
+                        toBlock: 5353002,
+                        filter: {
+                            from: '0xEA57Dc30959eb17c506E4dA095fa9181f3E0Ac6D',
+                            to: '0x13a22f1bba428eaaf56960530ec11118da916c11',
+                        }
+                    },
+                ]
+            ],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const data = yield (0, ethereumService_1.getEventsFromContract)(...actual);
+                console.log(data);
+                (0, chai_1.expect)(yield (0, ethereumService_1.getEventsFromContract)(...actual)).to.eql(expected);
+            }));
+        });
+    });
+});

package/esm/services/strategiesService.js

@@ -458,6 +458,19 @@ function parseLiquitySavingsLiqProtection(position, parseData) {
     };
     return _position;
 }
+function parseDebtInFrontRepay(position, parseData) {
+    const _position = (0, lodash_1.cloneDeep)(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.liquityDebtInFrontWithLimitTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.liquityDebtInFrontRepaySubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.specific = {
+        debtInFrontMin: triggerData.debtInFrontMin,
+        targetRepayRatioIncrease: subData.targetRatioIncrease,
+    };
+    return _position;
+}
 const parsingMethodsMapping = {
     [enums_1.ProtocolIdentifiers.StrategiesAutomation.MakerDAO]: {
         [enums_1.Strategies.Identifiers.SavingsLiqProtection]: parseMakerSavingsLiqProtection,
@@ -476,6 +489,7 @@ const parsingMethodsMapping = {
         [enums_1.Strategies.Identifiers.Boost]: parseLiquityLeverageManagement,
         [enums_1.Strategies.Identifiers.SavingsDsrPayback]: parseLiquitySavingsLiqProtection,
         [enums_1.Strategies.Identifiers.SavingsDsrSupply]: parseLiquitySavingsLiqProtection,
+        [enums_1.Strategies.Identifiers.DebtInFrontRepay]: parseDebtInFrontRepay,
     },
     [enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV2]: {
         [enums_1.Strategies.Identifiers.Repay]: parseAaveV2LeverageManagement,

package/esm/services/strategiesService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/services/strategiesService.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const enums_1 = require("../types/enums");
+const strategiesService_1 = require("./strategiesService");
+describe('Feature: strategiesService.ts', () => {
+    describe('When testing strategiesService.parseStrategiesAutomatedPosition', () => __awaiter(void 0, void 0, void 0, function* () {
+        // TODO: we should probably write this for every strategy?
+        const examples = [
+            [
+                {
+                    isEnabled: true,
+                    chainId: 1,
+                    subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+                    blockNumber: 18015756,
+                    subId: 379,
+                    owner: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+                    protocol: {
+                        id: enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV3,
+                        name: 'Aave',
+                        slug: 'aave',
+                        version: 'V3',
+                        fullName: 'Aave V3'
+                    },
+                    strategy: {
+                        isBundle: true,
+                        strategyOrBundleId: 8,
+                        strategyId: enums_1.Strategies.IdOverrides.LeverageManagement,
+                        protocol: {
+                            id: enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV3,
+                            name: 'Aave',
+                            slug: 'aave',
+                            version: 'V3',
+                            fullName: 'Aave V3'
+                        }
+                    },
+                    strategyData: {
+                        encoded: {
+                            triggerData: [
+                                '0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
+                            ],
+                            subData: [
+                                '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
+                                '0x0000000000000000000000000000000000000000000000000000000000000001',
+                                '0x0000000000000000000000000000000000000000000000000000000000000001',
+                                '0x0000000000000000000000000000000000000000000000000000000000000000'
+                            ]
+                        },
+                        decoded: {
+                            triggerData: {
+                                owner: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+                                market: '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e',
+                                ratio: 185,
+                                ratioState: 1
+                            },
+                            subData: { targetRatio: 200 }
+                        }
+                    },
+                    specific: {
+                        triggerRepayRatio: 185,
+                        targetRepayRatio: 200,
+                        repayEnabled: true,
+                        subId1: 379,
+                        mergeWithSameId: true
+                    }
+                },
+                {
+                    chainId: 1,
+                    blockNumber: 18015756,
+                    subscriptionEventData: {
+                        subId: '379',
+                        proxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
+                        subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+                        // @ts-ignore
+                        subStruct: {
+                            strategyOrBundleId: '8',
+                            isBundle: true,
+                            triggerData: ['0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001'],
+                            subData: [
+                                '0x0000000000000000000000000000000000000000000000001bc16d674ec80000', '0x0000000000000000000000000000000000000000000000000000000000000001',
+                                '0x0000000000000000000000000000000000000000000000000000000000000001', '0x0000000000000000000000000000000000000000000000000000000000000000',
+                            ],
+                        }
+                    },
+                    strategiesSubsData: {
+                        userProxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
+                        isEnabled: true,
+                        strategySubHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1'
+                    }
+                },
+            ],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${JSON.stringify(actual)} should return expected value: ${JSON.stringify(expected)}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                (0, chai_1.expect)((0, strategiesService_1.parseStrategiesAutomatedPosition)(actual)).to.eql(expected);
+            }));
+        });
+    }));
+});

package/esm/services/strategySubService.d.ts

@@ -1,7 +1,8 @@
+import type { OrderType } from '../types/enums';
 import { Bundles, ChainId, RatioState, Strategies } from '../types/enums';
 import type { EthereumAddress, StrategyOrBundleIds } from '../types';
 export declare const makerEncode: {
-    repayFromSavings(bundleId: StrategyOrBundleIds, vaultId: number, triggerRepayRatio: number, targetRepayRatio: number, isBundle?: boolean, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[])[];
+    repayFromSavings(bundleId: StrategyOrBundleIds, vaultId: number, triggerRepayRatio: number, targetRepayRatio: number, isBundle?: boolean, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds | Bundles.MainnetIds | Bundles.OptimismIds | Bundles.ArbitrumIds)[];
     closeOnPrice(vaultId: number, ratioState: RatioState, price: string, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
     trailingStop(vaultId: number, triggerPercentage: number, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, roundId: number, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
     leverageManagement(vaultId: number, triggerRepayRatio: string, triggerBoostRatio: string, targetBoostRatio: string, targetRepayRatio: string, boostEnabled: boolean): (string | number | boolean)[];
@@ -13,6 +14,7 @@ export declare const liquityEncode: {
     leverageManagement(triggerRepayRatio: string, triggerBoostRatio: string, targetBoostRatio: string, targetRepayRatio: string, boostEnabled: boolean): (string | boolean)[];
     dsrPayback(proxyAddress: EthereumAddress, triggerRatio: number, targetRatio: number): (boolean | string[] | Strategies.MainnetIds)[];
     dsrSupply(proxyAddress: EthereumAddress, triggerRatio: number, targetRatio: number): (boolean | string[] | Strategies.MainnetIds)[];
+    debtInFrontRepay(proxyAddress: EthereumAddress, debtInFrontMin: string, targetRatioIncrease: number): (boolean | string[] | Strategies.MainnetIds)[];
 };
 export declare const chickenBondsEncode: {
     rebond(bondId: number): string[];
@@ -56,8 +58,8 @@ export declare const morphoAaveV2Encode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string[];
 };
 export declare const exchangeEncode: {
-    dca(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, timestamp: number, interval: number, network: number): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds)[];
-    limitOrder(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, targetPrice: string, goodUntil: string, orderType: number): string[];
+    dca(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, timestamp: number, interval: number, network: ChainId): (boolean | string[] | Strategies.MainnetIds | Strategies.OptimismIds | Strategies.ArbitrumIds)[];
+    limitOrder(fromToken: EthereumAddress, toToken: EthereumAddress, amount: string, targetPrice: string, goodUntil: string | number, orderType: OrderType): string[];
 };
 export declare const sparkEncode: {
     leverageManagement(triggerRepayRatio: number, triggerBoostRatio: number, targetBoostRatio: number, targetRepayRatio: number, boostEnabled: boolean): string;

package/esm/services/strategySubService.js

@@ -30,6 +30,7 @@ exports.sparkEncode = exports.exchangeEncode = exports.morphoAaveV2Encode = expo
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const tokens_1 = require("@defisaver/tokens");
 const enums_1 = require("../types/enums");
+const constants_1 = require("../constants");
 const subDataService = __importStar(require("./subDataService"));
 const triggerService = __importStar(require("./triggerService"));
 const utils_1 = require("./utils");
@@ -120,6 +121,14 @@ exports.liquityEncode = {
         const isBundle = false;
         return [strategyOrBundleId, isBundle, triggerData, subData];
     },
+    debtInFrontRepay(proxyAddress, debtInFrontMin, targetRatioIncrease) {
+        (0, utils_1.requireAddress)(proxyAddress);
+        const subData = subDataService.liquityDebtInFrontRepaySubData.encode(targetRatioIncrease);
+        const triggerData = triggerService.liquityDebtInFrontWithLimitTrigger.encode(proxyAddress, debtInFrontMin);
+        const strategyOrBundleId = enums_1.Strategies.MainnetIds.LIQUITY_DEBT_IN_FRONT_REPAY;
+        const isBundle = false;
+        return [strategyOrBundleId, isBundle, triggerData, subData];
+    },
 };
 exports.chickenBondsEncode = {
     rebond(bondId) {
@@ -180,12 +189,7 @@ exports.exchangeEncode = {
         (0, utils_1.requireAddresses)([fromToken, toToken]);
         const subData = subDataService.exchangeDcaSubData.encode(fromToken, toToken, amount, interval);
         const triggerData = triggerService.exchangeTimestampTrigger.encode(timestamp, interval);
-        const selectedNetwork = network === 1
-            ? 'MainnetIds'
-            : network === 10
-                ? 'OptimismIds'
-                : 'ArbitrumIds';
-        const strategyId = enums_1.Strategies[selectedNetwork].EXCHANGE_DCA;
+        const strategyId = constants_1.STRATEGY_IDS[network].EXCHANGE_DCA;
         return [strategyId, false, triggerData, subData];
     },
     limitOrder(fromToken, toToken, amount, targetPrice, goodUntil, orderType) {

package/esm/services/strategySubService.test.d.ts

@@ -0,0 +1 @@
+export {};