@defisaver/automation-sdk 2.0.6 → 2.0.9

package/.env

@@ -0,0 +1,4 @@
+RPC_1=https://mainnet.infura.io/v3/a3503e4501d040cd9ea2c913c68983a1
+RPC_10=https://opt-mainnet.g.alchemy.com/v2/Pwh-hdbsP7Bf0CP_UMw4_Pw-NfHhSpIA
+RPC_8453=https://base-mainnet.g.alchemy.com/v2/TERsAaPNcA7sgCVHHAMBvd95UtT4wCEf
+RPC_42161=https://arb-mainnet.g.alchemy.com/v2/Pwh-hdbsP7Bf0CP_UMw4_Pw-NfHhSpIA

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/LegacyAutomation.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const decimal_js_1 = __importDefault(require("decimal.js"));
 const contractService_1 = require("../../services/contractService");
 const ethereumService_1 = require("../../services/ethereumService");
 const utils_1 = require("../../services/utils");
@@ -82,13 +83,18 @@ class LegacyAutomation extends Automation_1.default {
     }
     getParsedSubscriptions(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Legacy automation was disabled on block 18213086
+            if (!(options === null || options === void 0 ? void 0 : options.fromBlock)
+                || (options === null || options === void 0 ? void 0 : options.fromBlock) === 'latest'
+                || (options === null || options === void 0 ? void 0 : options.fromBlock) === 'pending'
+                || ((options === null || options === void 0 ? void 0 : options.fromBlock) && new decimal_js_1.default(options === null || options === void 0 ? void 0 : options.fromBlock.toString()).lt(18213086))) {
+                return [];
+            }
             const subscriptions = yield this._getSubscriptions(addresses, options);
-            // @ts-ignore
             return subscriptions.map((sub) => ({
                 chainId: this.chainId,
                 owner: sub[this.getOwnerPropName()],
-                isEnabled: ((options === null || options === void 0 ? void 0 : options.fromBlock) && (options === null || options === void 0 ? void 0 : options.fromBlock) !== 'latest')
-                    ? (options === null || options === void 0 ? void 0 : options.fromBlock) > 18213086 : false,
+                isEnabled: true,
                 protocol: this.protocol,
                 specific: Object.assign({}, sub),
                 strategy: {

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/automation/private/StrategiesAutomation.d.ts

@@ -20,6 +20,10 @@ export default class StrategiesAutomation extends Automation {
     protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
     protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
     protected getParsedSubscriptions(parseData: ParseData): Position.Automated | null;
+    /**
+     * @description Removes expired Limit Order subscriptions
+     */
+    protected removeExpiredSubscriptions(subscriptions: (Position.Automated | null)[]): (Position.Automated | null)[];
     protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;

package/esm/automation/private/StrategiesAutomation.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const enums_1 = require("../../types/enums");
 const utils_1 = require("../../services/utils");
 const contractService_1 = require("../../services/contractService");
 const ethereumService_1 = require("../../services/ethereumService");
@@ -70,14 +71,38 @@ class StrategiesAutomation extends Automation_1.default {
     getParsedSubscriptions(parseData) {
         return (0, strategiesService_1.parseStrategiesAutomatedPosition)(parseData);
     }
+    /**
+     * @description Removes expired Limit Order subscriptions
+     */
+    removeExpiredSubscriptions(subscriptions) {
+        return subscriptions.filter((subscription) => {
+            if (!subscription) {
+                return true;
+            }
+            const { protocol, strategy, strategyData } = subscription;
+            if (protocol.id === enums_1.ProtocolIdentifiers.StrategiesAutomation.Exchange
+                && strategy.strategyId === enums_1.Strategies.Identifiers.LimitOrder) {
+                return new decimal_js_1.default(strategyData.decoded.triggerData.goodUntil).gt(new decimal_js_1.default(Date.now()).div(1000));
+            }
+            return true;
+        });
+    }
     _getSubscriptions(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _options = Object.assign(Object.assign({}, (0, utils_1.addToObjectIf)((0, utils_1.isDefined)(options), options)), (0, utils_1.addToObjectIf)((0, utils_1.isDefined)(addresses), { filter: { proxy: addresses } }));
-            const subscriptionEvents = (yield this.getSubscriptionEventsFromSubStorage(_options)); // TODO PlaceholderType
+            let subscriptionEvents = (yield this.getSubscriptionEventsFromSubStorage(_options)); // TODO PlaceholderType
             let subscriptions = [];
             if (subscriptionEvents) {
-                // @ts-ignore
-                const strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId), _options.toBlock);
+                let strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId), _options.toBlock);
+                if (_options.enabledOnly) {
+                    const filteredSubscriptionEvents = [];
+                    strategiesSubs = strategiesSubs.filter((sub, index) => {
+                        if (sub === null || sub === void 0 ? void 0 : sub.isEnabled)
+                            filteredSubscriptionEvents.push(subscriptionEvents[index]);
+                        return sub === null || sub === void 0 ? void 0 : sub.isEnabled;
+                    });
+                    subscriptionEvents = filteredSubscriptionEvents;
+                }
                 subscriptions = yield Promise.all(strategiesSubs.map((sub, index) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
                     let latestUpdate = subscriptionEvents[index].returnValues;
@@ -120,7 +145,7 @@ class StrategiesAutomation extends Automation_1.default {
                     }, []);
                 }
             }
-            return subscriptions;
+            return _options.unexpiredOnly ? this.removeExpiredSubscriptions(subscriptions) : subscriptions;
         });
     }
     getSubscriptions(options) {

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);
+            }));
+        });
+    }));
+});