@defisaver/automation-sdk 3.3.19-sub-fetching.2-dev → 3.3.20

package/cjs/automation/private/StrategiesAutomation.d.ts

@@ -1,6 +1,6 @@
 import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
-import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber, ApiSubscriptionRecord } from '../../types';
+import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber } from '../../types';
 import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
@@ -30,10 +30,6 @@ export default class StrategiesAutomation extends Automation {
     protected mergeSubs(_subscriptions: (Position.Automated | null)[]): Position.Automated[];
     protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
-    /**
-     * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
-     */
-    parseSubscriptionsFromApi(records: ApiSubscriptionRecord[], options?: SubscriptionOptions): (Position.Automated | null)[];
     getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
 }
 export {};

package/cjs/automation/private/StrategiesAutomation.js

@@ -19,7 +19,6 @@ const utils_1 = require("../../services/utils");
 const contractService_1 = require("../../services/contractService");
 const ethereumService_1 = require("../../services/ethereumService");
 const strategiesService_1 = require("../../services/strategiesService");
-const apiSubscriptionsService_1 = require("../../services/apiSubscriptionsService");
 const Automation_1 = __importDefault(require("./Automation"));
 class StrategiesAutomation extends Automation_1.default {
     constructor(args) {
@@ -190,17 +189,6 @@ class StrategiesAutomation extends Automation_1.default {
             return this._getSubscriptions(undefined, options);
         });
     }
-    /**
-     * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
-     */
-    parseSubscriptionsFromApi(records, options) {
-        const filtered = (options === null || options === void 0 ? void 0 : options.enabledOnly) ? records.filter((record) => record.is_enabled) : records;
-        let subscriptions = filtered.map((record) => this.getParsedSubscriptions((0, apiSubscriptionsService_1.parseDataFromApiSubscription)(record, this.chainId)));
-        if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
-            subscriptions = this.mergeSubs(subscriptions);
-        }
-        return (options === null || options === void 0 ? void 0 : options.unexpiredOnly) ? this.removeExpiredSubscriptions(subscriptions) : subscriptions;
-    }
     getSubscriptionsFor(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this._getSubscriptions(addresses, options);

package/cjs/automation/private/StrategiesAutomation.test.js

@@ -693,55 +693,4 @@ describe('Feature: StrategiesAutomation.ts', () => {
             (0, chai_1.expect)(loneBoost === null || loneBoost === void 0 ? void 0 : loneBoost.subId).to.equal(1);
         });
     }));
-    describe('When testing StrategiesAutomation.parseSubscriptionsFromApi', () => {
-        const strategiesAutomation = new StrategiesAutomation_1.default({
-            chainId: enums_1.ChainId.Ethereum,
-            provider: Web3_1,
-            providerFork: null,
-        });
-        const owner = '0x9cB7E19861665366011899d74E75d4F2A419aEeD';
-        const subData = [
-            '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-            '0x0000000000000000000000000000000000000000000000000000000000000001',
-            '0x0000000000000000000000000000000000000000000000000000000000000001',
-            '0x0000000000000000000000000000000000000000000000000000000000000000',
-        ];
-        // Aave V3 leverage management: repay (bundle 8, ratio under) and boost (bundle 9, ratio over) for the same owner and market
-        const repay = {
-            id: 379,
-            wallet: owner,
-            wallet_type: 'safe',
-            is_enabled: true,
-            is_bundle: true,
-            strategy_or_bundle_id: 8,
-            strategy_ids: [34, 35],
-            sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001'],
-            sub_data: subData,
-            block_number: 18015756,
-            additional_triggers: null,
-        };
-        const boost = Object.assign(Object.assign({}, repay), { id: 380, is_enabled: false, strategy_or_bundle_id: 9, sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111', trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'] });
-        it('Given API records should return parsed positions', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost]);
-            (0, chai_1.expect)(positions).to.have.length(2);
-            (0, chai_1.expect)(positions.map((p) => p === null || p === void 0 ? void 0 : p.subId)).to.eql([379, 380]);
-            (0, chai_1.expect)(positions.map((p) => p === null || p === void 0 ? void 0 : p.isEnabled)).to.eql([true, false]);
-        });
-        it('Given mergeSubs option should merge the repay and boost pair', () => {
-            var _a, _b;
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { mergeSubs: true });
-            (0, chai_1.expect)(positions).to.have.length(1);
-            (0, chai_1.expect)((_a = positions[0]) === null || _a === void 0 ? void 0 : _a.subIds).to.eql([379, 380]);
-            (0, chai_1.expect)((_b = positions[0]) === null || _b === void 0 ? void 0 : _b.isEnabled).to.equal(true);
-        });
-        it('Given enabledOnly option should drop disabled records before parsing', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { enabledOnly: true });
-            (0, chai_1.expect)(positions.map((p) => p === null || p === void 0 ? void 0 : p.subId)).to.eql([379]);
-        });
-        it('Given a record of an unknown strategy should return null for it', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([Object.assign(Object.assign({}, repay), { strategy_or_bundle_id: 9999 })]);
-            (0, chai_1.expect)(positions).to.eql([null]);
-        });
-    });
 });

package/cjs/services/strategiesService.test.js

@@ -83,6 +83,7 @@ describe('Feature: strategiesService.ts', () => {
                         subId: '379',
                         proxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
                         subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+                        // @ts-ignore
                         subStruct: {
                             strategyOrBundleId: '8',
                             isBundle: true,

package/cjs/types/index.d.ts

@@ -1,7 +1,7 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
 import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
@@ -53,21 +53,6 @@ interface _SubscriptionOptions {
     unexpiredOnly: boolean;
 }
 export type SubscriptionOptions = Partial<_SubscriptionOptions>;
-/** Subscription record as returned by the automation API (GET /v1/subscriptions) */
-export interface ApiSubscriptionRecord {
-    id: number;
-    wallet: EthereumAddress;
-    wallet_type: string;
-    is_enabled: boolean;
-    is_bundle: boolean;
-    strategy_or_bundle_id: number;
-    strategy_ids: number[];
-    sub_data_hash: string;
-    trigger_data: string[];
-    sub_data: string[];
-    block_number: number;
-    additional_triggers: string[] | null;
-}
 export declare namespace Interfaces {
     interface ProtocolBase {
         id: ProtocolIdentifiers.StrategiesAutomation | ProtocolIdentifiers.LegacyAutomation;
@@ -306,17 +291,10 @@ export interface BundlesInfo {
     [ChainId.Base]: BaseBundleInfo;
 }
 export type StrategyOrBundleIds = typeof Strategies.MainnetIds[keyof typeof Strategies.MainnetIds] | typeof Strategies.OptimismIds[keyof typeof Strategies.OptimismIds] | typeof Strategies.ArbitrumIds[keyof typeof Strategies.ArbitrumIds] | typeof Strategies.BaseIds[keyof typeof Strategies.BaseIds] | typeof Bundles.MainnetIds[keyof typeof Bundles.MainnetIds] | typeof Bundles.OptimismIds[keyof typeof Bundles.OptimismIds] | typeof Bundles.ArbitrumIds[keyof typeof Bundles.ArbitrumIds] | typeof Bundles.BaseIds[keyof typeof Bundles.BaseIds];
-/** Fields of the Subscribe event that parsing relies on */
-export interface SubscriptionEventData {
-    subId: string;
-    proxy: EthereumAddress;
-    subHash: string;
-    subStruct: StrategyModel.StrategySubStructOutputStruct;
-}
 export interface ParseData {
     chainId: ChainId;
     blockNumber: BlockNumber;
-    subscriptionEventData: SubscriptionEventData;
+    subscriptionEventData: Subscribe['returnValues'];
     strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct;
 }
 type MapToProtocolVersion<T> = {

package/esm/automation/private/StrategiesAutomation.d.ts

@@ -1,6 +1,6 @@
 import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
-import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber, ApiSubscriptionRecord } from '../../types';
+import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber } from '../../types';
 import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
@@ -30,10 +30,6 @@ export default class StrategiesAutomation extends Automation {
     protected mergeSubs(_subscriptions: (Position.Automated | null)[]): Position.Automated[];
     protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
-    /**
-     * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
-     */
-    parseSubscriptionsFromApi(records: ApiSubscriptionRecord[], options?: SubscriptionOptions): (Position.Automated | null)[];
     getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
 }
 export {};

package/esm/automation/private/StrategiesAutomation.js

@@ -14,7 +14,6 @@ import { addToObjectIf, isDefined, isUndefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
 import { getEventsFromContract, multicall } from '../../services/ethereumService';
 import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
-import { parseDataFromApiSubscription } from '../../services/apiSubscriptionsService';
 import Automation from './Automation';
 export default class StrategiesAutomation extends Automation {
     constructor(args) {
@@ -185,17 +184,6 @@ export default class StrategiesAutomation extends Automation {
             return this._getSubscriptions(undefined, options);
         });
     }
-    /**
-     * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
-     */
-    parseSubscriptionsFromApi(records, options) {
-        const filtered = (options === null || options === void 0 ? void 0 : options.enabledOnly) ? records.filter((record) => record.is_enabled) : records;
-        let subscriptions = filtered.map((record) => this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId)));
-        if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
-            subscriptions = this.mergeSubs(subscriptions);
-        }
-        return (options === null || options === void 0 ? void 0 : options.unexpiredOnly) ? this.removeExpiredSubscriptions(subscriptions) : subscriptions;
-    }
     getSubscriptionsFor(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this._getSubscriptions(addresses, options);

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

@@ -688,55 +688,4 @@ describe('Feature: StrategiesAutomation.ts', () => {
             expect(loneBoost === null || loneBoost === void 0 ? void 0 : loneBoost.subId).to.equal(1);
         });
     }));
-    describe('When testing StrategiesAutomation.parseSubscriptionsFromApi', () => {
-        const strategiesAutomation = new StrategiesAutomation({
-            chainId: ChainId.Ethereum,
-            provider: Web3_1,
-            providerFork: null,
-        });
-        const owner = '0x9cB7E19861665366011899d74E75d4F2A419aEeD';
-        const subData = [
-            '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-            '0x0000000000000000000000000000000000000000000000000000000000000001',
-            '0x0000000000000000000000000000000000000000000000000000000000000001',
-            '0x0000000000000000000000000000000000000000000000000000000000000000',
-        ];
-        // Aave V3 leverage management: repay (bundle 8, ratio under) and boost (bundle 9, ratio over) for the same owner and market
-        const repay = {
-            id: 379,
-            wallet: owner,
-            wallet_type: 'safe',
-            is_enabled: true,
-            is_bundle: true,
-            strategy_or_bundle_id: 8,
-            strategy_ids: [34, 35],
-            sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001'],
-            sub_data: subData,
-            block_number: 18015756,
-            additional_triggers: null,
-        };
-        const boost = Object.assign(Object.assign({}, repay), { id: 380, is_enabled: false, strategy_or_bundle_id: 9, sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111', trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'] });
-        it('Given API records should return parsed positions', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost]);
-            expect(positions).to.have.length(2);
-            expect(positions.map((p) => p === null || p === void 0 ? void 0 : p.subId)).to.eql([379, 380]);
-            expect(positions.map((p) => p === null || p === void 0 ? void 0 : p.isEnabled)).to.eql([true, false]);
-        });
-        it('Given mergeSubs option should merge the repay and boost pair', () => {
-            var _a, _b;
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { mergeSubs: true });
-            expect(positions).to.have.length(1);
-            expect((_a = positions[0]) === null || _a === void 0 ? void 0 : _a.subIds).to.eql([379, 380]);
-            expect((_b = positions[0]) === null || _b === void 0 ? void 0 : _b.isEnabled).to.equal(true);
-        });
-        it('Given enabledOnly option should drop disabled records before parsing', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { enabledOnly: true });
-            expect(positions.map((p) => p === null || p === void 0 ? void 0 : p.subId)).to.eql([379]);
-        });
-        it('Given a record of an unknown strategy should return null for it', () => {
-            const positions = strategiesAutomation.parseSubscriptionsFromApi([Object.assign(Object.assign({}, repay), { strategy_or_bundle_id: 9999 })]);
-            expect(positions).to.eql([null]);
-        });
-    });
 });

package/esm/services/strategiesService.test.js

@@ -81,6 +81,7 @@ describe('Feature: strategiesService.ts', () => {
                         subId: '379',
                         proxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
                         subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+                        // @ts-ignore
                         subStruct: {
                             strategyOrBundleId: '8',
                             isBundle: true,

package/esm/types/index.d.ts

@@ -1,7 +1,7 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
 import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
@@ -53,21 +53,6 @@ interface _SubscriptionOptions {
     unexpiredOnly: boolean;
 }
 export type SubscriptionOptions = Partial<_SubscriptionOptions>;
-/** Subscription record as returned by the automation API (GET /v1/subscriptions) */
-export interface ApiSubscriptionRecord {
-    id: number;
-    wallet: EthereumAddress;
-    wallet_type: string;
-    is_enabled: boolean;
-    is_bundle: boolean;
-    strategy_or_bundle_id: number;
-    strategy_ids: number[];
-    sub_data_hash: string;
-    trigger_data: string[];
-    sub_data: string[];
-    block_number: number;
-    additional_triggers: string[] | null;
-}
 export declare namespace Interfaces {
     interface ProtocolBase {
         id: ProtocolIdentifiers.StrategiesAutomation | ProtocolIdentifiers.LegacyAutomation;
@@ -306,17 +291,10 @@ export interface BundlesInfo {
     [ChainId.Base]: BaseBundleInfo;
 }
 export type StrategyOrBundleIds = typeof Strategies.MainnetIds[keyof typeof Strategies.MainnetIds] | typeof Strategies.OptimismIds[keyof typeof Strategies.OptimismIds] | typeof Strategies.ArbitrumIds[keyof typeof Strategies.ArbitrumIds] | typeof Strategies.BaseIds[keyof typeof Strategies.BaseIds] | typeof Bundles.MainnetIds[keyof typeof Bundles.MainnetIds] | typeof Bundles.OptimismIds[keyof typeof Bundles.OptimismIds] | typeof Bundles.ArbitrumIds[keyof typeof Bundles.ArbitrumIds] | typeof Bundles.BaseIds[keyof typeof Bundles.BaseIds];
-/** Fields of the Subscribe event that parsing relies on */
-export interface SubscriptionEventData {
-    subId: string;
-    proxy: EthereumAddress;
-    subHash: string;
-    subStruct: StrategyModel.StrategySubStructOutputStruct;
-}
 export interface ParseData {
     chainId: ChainId;
     blockNumber: BlockNumber;
-    subscriptionEventData: SubscriptionEventData;
+    subscriptionEventData: Subscribe['returnValues'];
     strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct;
 }
 type MapToProtocolVersion<T> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.19-sub-fetching.2-dev",
+  "version": "3.3.20",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -22,6 +22,17 @@
   "author": "DeFi Saver",
   "repository": "https://github.com/defisaver/automation-sdk",
   "license": "ISC",
+  "overrides": {
+    "axios": "^1.19.0",
+    "tar": "^7.5.21",
+    "ws": "^8.18.3",
+    "form-data": "^4.0.4",
+    "tough-cookie": "^4.1.3",
+    "qs": "^6.16.0",
+    "serialize-javascript": "^7.1.0",
+    "fast-uri": "^3.1.8",
+    "js-yaml": "^4.3.2"
+  },
   "dependencies": {
     "@defisaver/sdk": "^1.3.22",
     "@defisaver/tokens": "^1.6.19",
@@ -44,7 +55,6 @@
     "dotenv": "^16.3.1",
     "eslint": "^8.49.0",
     "husky": "^8.0.0",
-    "jsdoc-to-markdown": "^6.0.1",
     "mocha": "^10.2.0",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.0",

package/src/automation/private/StrategiesAutomation.test.ts

@@ -1,8 +1,7 @@
 import Web3 from 'web3';
 import { expect } from 'chai';
 
-import { ChainId } from '../../types/enums';
-import type { ApiSubscriptionRecord } from '../../types';
+import {ChainId} from '../../types/enums';
 
 import '../../configuration';
 import StrategiesAutomation from './StrategiesAutomation';
@@ -701,67 +700,4 @@ describe('Feature: StrategiesAutomation.ts', () => {
       expect(loneBoost?.subId).to.equal(1);
     });
   });
-
-  describe('When testing StrategiesAutomation.parseSubscriptionsFromApi', () => {
-    const strategiesAutomation = new StrategiesAutomation({
-      chainId: ChainId.Ethereum,
-      provider: Web3_1,
-      providerFork: null!,
-    });
-
-    const owner = '0x9cB7E19861665366011899d74E75d4F2A419aEeD';
-    const subData = [
-      '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-      '0x0000000000000000000000000000000000000000000000000000000000000001',
-      '0x0000000000000000000000000000000000000000000000000000000000000001',
-      '0x0000000000000000000000000000000000000000000000000000000000000000',
-    ];
-    // Aave V3 leverage management: repay (bundle 8, ratio under) and boost (bundle 9, ratio over) for the same owner and market
-    const repay: ApiSubscriptionRecord = {
-      id: 379,
-      wallet: owner,
-      wallet_type: 'safe',
-      is_enabled: true,
-      is_bundle: true,
-      strategy_or_bundle_id: 8,
-      strategy_ids: [34, 35],
-      sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001'],
-      sub_data: subData,
-      block_number: 18015756,
-      additional_triggers: null,
-    };
-    const boost: ApiSubscriptionRecord = {
-      ...repay,
-      id: 380,
-      is_enabled: false,
-      strategy_or_bundle_id: 9,
-      sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111',
-      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'],
-    };
-
-    it('Given API records should return parsed positions', () => {
-      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost]);
-      expect(positions).to.have.length(2);
-      expect(positions.map((p) => p?.subId)).to.eql([379, 380]);
-      expect(positions.map((p) => p?.isEnabled)).to.eql([true, false]);
-    });
-
-    it('Given mergeSubs option should merge the repay and boost pair', () => {
-      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { mergeSubs: true });
-      expect(positions).to.have.length(1);
-      expect(positions[0]?.subIds).to.eql([379, 380]);
-      expect(positions[0]?.isEnabled).to.equal(true);
-    });
-
-    it('Given enabledOnly option should drop disabled records before parsing', () => {
-      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost], { enabledOnly: true });
-      expect(positions.map((p) => p?.subId)).to.eql([379]);
-    });
-
-    it('Given a record of an unknown strategy should return null for it', () => {
-      const positions = strategiesAutomation.parseSubscriptionsFromApi([{ ...repay, strategy_or_bundle_id: 9999 }]);
-      expect(positions).to.eql([null]);
-    });
-  });
 });

package/src/automation/private/StrategiesAutomation.ts

@@ -4,7 +4,6 @@ import type { PastEventOptions } from 'web3-eth-contract';
 import PromisePool from 'es6-promise-pool';
 import type {
   Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, PlaceholderType, BlockNumber,
-  ApiSubscriptionRecord,
 } from '../../types';
 import type {
   StrategyModel, Subscribe, SubStorage, UpdateData,
@@ -16,7 +15,6 @@ import { addToObjectIf, isDefined, isUndefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
 import { getEventsFromContract, multicall } from '../../services/ethereumService';
 import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
-import { parseDataFromApiSubscription } from '../../services/apiSubscriptionsService';
 
 import Automation from './Automation';
 
@@ -261,21 +259,6 @@ export default class StrategiesAutomation extends Automation {
     return this._getSubscriptions(undefined, options);
   }
 
-  /**
-   * @description Parses subscriptions returned by the automation API (GET /v1/subscriptions)
-   */
-  public parseSubscriptionsFromApi(records: ApiSubscriptionRecord[], options?: SubscriptionOptions): (Position.Automated | null)[] {
-    const filtered = options?.enabledOnly ? records.filter((record) => record.is_enabled) : records;
-
-    let subscriptions = filtered.map((record) => this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId)));
-
-    if (options?.mergeSubs) {
-      subscriptions = this.mergeSubs(subscriptions);
-    }
-
-    return options?.unexpiredOnly ? this.removeExpiredSubscriptions(subscriptions) : subscriptions;
-  }
-
   public async getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]> {
     return this._getSubscriptions(addresses, options);
   }

package/src/services/strategiesService.test.ts

@@ -76,6 +76,7 @@ describe('Feature: strategiesService.ts', () => {
             subId: '379',
             proxy: '0x9cb7e19861665366011899d74e75d4f2a419aeed',
             subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
+            // @ts-ignore
             subStruct:
               {
                 strategyOrBundleId: '8',

package/src/types/index.ts

@@ -1,7 +1,7 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
 import type {
   ChainId, Strategies, Bundles, ProtocolIdentifiers,
   RatioState,
@@ -72,22 +72,6 @@ interface _SubscriptionOptions {
 
 export type SubscriptionOptions = Partial<_SubscriptionOptions>;
 
-/** Subscription record as returned by the automation API (GET /v1/subscriptions) */
-export interface ApiSubscriptionRecord {
-  id: number,
-  wallet: EthereumAddress,
-  wallet_type: string,
-  is_enabled: boolean,
-  is_bundle: boolean,
-  strategy_or_bundle_id: number,
-  strategy_ids: number[],
-  sub_data_hash: string,
-  trigger_data: string[],
-  sub_data: string[],
-  block_number: number,
-  additional_triggers: string[] | null,
-}
-
 export declare namespace Interfaces {
   interface ProtocolBase {
     id: ProtocolIdentifiers.StrategiesAutomation | ProtocolIdentifiers.LegacyAutomation,
@@ -385,18 +369,10 @@ export type StrategyOrBundleIds =
   | typeof Bundles.ArbitrumIds[keyof typeof Bundles.ArbitrumIds]
   | typeof Bundles.BaseIds[keyof typeof Bundles.BaseIds];
 
-/** Fields of the Subscribe event that parsing relies on */
-export interface SubscriptionEventData {
-  subId: string,
-  proxy: EthereumAddress,
-  subHash: string,
-  subStruct: StrategyModel.StrategySubStructOutputStruct,
-}
-
 export interface ParseData {
   chainId: ChainId,
   blockNumber: BlockNumber,
-  subscriptionEventData: SubscriptionEventData,
+  subscriptionEventData: Subscribe['returnValues']
   strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct,
 }
 

package/cjs/services/apiSubscriptionsService.d.ts

@@ -1,7 +0,0 @@
-import type { ApiSubscriptionRecord, ParseData } from '../types';
-import type { ChainId } from '../types/enums';
-/**
- * @description Maps a subscription record returned by the automation API to the data
- * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
- */
-export declare function parseDataFromApiSubscription(record: ApiSubscriptionRecord, chainId: ChainId): ParseData;

package/cjs/services/apiSubscriptionsService.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDataFromApiSubscription = void 0;
-function addHexPrefix(value) {
-    return value.startsWith('0x') ? value : `0x${value}`;
-}
-/**
- * @description Maps a subscription record returned by the automation API to the data
- * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
- */
-function parseDataFromApiSubscription(record, chainId) {
-    return {
-        chainId,
-        blockNumber: record.block_number,
-        subscriptionEventData: {
-            subId: record.id.toString(),
-            proxy: record.wallet,
-            subHash: record.sub_data_hash,
-            subStruct: {
-                strategyOrBundleId: record.strategy_or_bundle_id.toString(),
-                isBundle: record.is_bundle,
-                triggerData: record.trigger_data.map(addHexPrefix),
-                subData: record.sub_data.map(addHexPrefix),
-            },
-        },
-        strategiesSubsData: {
-            userProxy: record.wallet,
-            isEnabled: record.is_enabled,
-            strategySubHash: record.sub_data_hash,
-        },
-    };
-}
-exports.parseDataFromApiSubscription = parseDataFromApiSubscription;

package/cjs/services/apiSubscriptionsService.test.d.ts

@@ -1 +0,0 @@
-import '../configuration';

package/cjs/services/apiSubscriptionsService.test.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const enums_1 = require("../types/enums");
-require("../configuration");
-const apiSubscriptionsService_1 = require("./apiSubscriptionsService");
-const strategiesService_1 = require("./strategiesService");
-describe('Feature: apiSubscriptionsService.ts', () => {
-    describe('When testing apiSubscriptionsService.parseDataFromApiSubscription', () => {
-        // same subscription as in strategiesService.test.ts, in the shape the automation API returns it
-        const record = {
-            id: 379,
-            wallet: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-            wallet_type: 'safe',
-            is_enabled: true,
-            is_bundle: true,
-            strategy_or_bundle_id: 8,
-            strategy_ids: [34, 35],
-            sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            trigger_data: [
-                '0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-            ],
-            sub_data: [
-                '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-                '0x0000000000000000000000000000000000000000000000000000000000000001',
-                '0x0000000000000000000000000000000000000000000000000000000000000001',
-                '0x0000000000000000000000000000000000000000000000000000000000000000',
-            ],
-            block_number: 18015756,
-            additional_triggers: null,
-        };
-        const fromEvents = {
-            chainId: enums_1.ChainId.Ethereum,
-            blockNumber: 18015756,
-            subscriptionEventData: {
-                subId: '379',
-                proxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-                subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-                subStruct: {
-                    strategyOrBundleId: '8',
-                    isBundle: true,
-                    triggerData: [
-                        '0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-                    ],
-                    subData: record.sub_data,
-                },
-            },
-            strategiesSubsData: {
-                userProxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-                isEnabled: true,
-                strategySubHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            },
-        };
-        it('Given an API record should return the same parse data as Subscribe event and SubStorage would', () => {
-            (0, chai_1.expect)((0, apiSubscriptionsService_1.parseDataFromApiSubscription)(record, enums_1.ChainId.Ethereum)).to.eql(fromEvents);
-        });
-        it('Given an API record the parsed position should match the one parsed from events', () => {
-            const fromApi = (0, strategiesService_1.parseStrategiesAutomatedPosition)((0, apiSubscriptionsService_1.parseDataFromApiSubscription)(record, enums_1.ChainId.Ethereum));
-            (0, chai_1.expect)(fromApi).to.not.equal(null);
-            (0, chai_1.expect)(fromApi).to.eql((0, strategiesService_1.parseStrategiesAutomatedPosition)(fromEvents));
-        });
-        it('Given a disabled record should keep it disabled', () => {
-            const parseData = (0, apiSubscriptionsService_1.parseDataFromApiSubscription)(Object.assign(Object.assign({}, record), { is_enabled: false }), enums_1.ChainId.Ethereum);
-            (0, chai_1.expect)(parseData.strategiesSubsData.isEnabled).to.equal(false);
-        });
-    });
-});

package/esm/services/apiSubscriptionsService.d.ts

@@ -1,7 +0,0 @@
-import type { ApiSubscriptionRecord, ParseData } from '../types';
-import type { ChainId } from '../types/enums';
-/**
- * @description Maps a subscription record returned by the automation API to the data
- * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
- */
-export declare function parseDataFromApiSubscription(record: ApiSubscriptionRecord, chainId: ChainId): ParseData;

package/esm/services/apiSubscriptionsService.js

@@ -1,29 +0,0 @@
-function addHexPrefix(value) {
-    return value.startsWith('0x') ? value : `0x${value}`;
-}
-/**
- * @description Maps a subscription record returned by the automation API to the data
- * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
- */
-export function parseDataFromApiSubscription(record, chainId) {
-    return {
-        chainId,
-        blockNumber: record.block_number,
-        subscriptionEventData: {
-            subId: record.id.toString(),
-            proxy: record.wallet,
-            subHash: record.sub_data_hash,
-            subStruct: {
-                strategyOrBundleId: record.strategy_or_bundle_id.toString(),
-                isBundle: record.is_bundle,
-                triggerData: record.trigger_data.map(addHexPrefix),
-                subData: record.sub_data.map(addHexPrefix),
-            },
-        },
-        strategiesSubsData: {
-            userProxy: record.wallet,
-            isEnabled: record.is_enabled,
-            strategySubHash: record.sub_data_hash,
-        },
-    };
-}

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

@@ -1 +0,0 @@
-import '../configuration';

package/esm/services/apiSubscriptionsService.test.js

@@ -1,65 +0,0 @@
-import { expect } from 'chai';
-import { ChainId } from '../types/enums';
-import '../configuration';
-import { parseDataFromApiSubscription } from './apiSubscriptionsService';
-import { parseStrategiesAutomatedPosition } from './strategiesService';
-describe('Feature: apiSubscriptionsService.ts', () => {
-    describe('When testing apiSubscriptionsService.parseDataFromApiSubscription', () => {
-        // same subscription as in strategiesService.test.ts, in the shape the automation API returns it
-        const record = {
-            id: 379,
-            wallet: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-            wallet_type: 'safe',
-            is_enabled: true,
-            is_bundle: true,
-            strategy_or_bundle_id: 8,
-            strategy_ids: [34, 35],
-            sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            trigger_data: [
-                '0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-            ],
-            sub_data: [
-                '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-                '0x0000000000000000000000000000000000000000000000000000000000000001',
-                '0x0000000000000000000000000000000000000000000000000000000000000001',
-                '0x0000000000000000000000000000000000000000000000000000000000000000',
-            ],
-            block_number: 18015756,
-            additional_triggers: null,
-        };
-        const fromEvents = {
-            chainId: ChainId.Ethereum,
-            blockNumber: 18015756,
-            subscriptionEventData: {
-                subId: '379',
-                proxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-                subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-                subStruct: {
-                    strategyOrBundleId: '8',
-                    isBundle: true,
-                    triggerData: [
-                        '0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-                    ],
-                    subData: record.sub_data,
-                },
-            },
-            strategiesSubsData: {
-                userProxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-                isEnabled: true,
-                strategySubHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-            },
-        };
-        it('Given an API record should return the same parse data as Subscribe event and SubStorage would', () => {
-            expect(parseDataFromApiSubscription(record, ChainId.Ethereum)).to.eql(fromEvents);
-        });
-        it('Given an API record the parsed position should match the one parsed from events', () => {
-            const fromApi = parseStrategiesAutomatedPosition(parseDataFromApiSubscription(record, ChainId.Ethereum));
-            expect(fromApi).to.not.equal(null);
-            expect(fromApi).to.eql(parseStrategiesAutomatedPosition(fromEvents));
-        });
-        it('Given a disabled record should keep it disabled', () => {
-            const parseData = parseDataFromApiSubscription(Object.assign(Object.assign({}, record), { is_enabled: false }), ChainId.Ethereum);
-            expect(parseData.strategiesSubsData.isEnabled).to.equal(false);
-        });
-    });
-});

package/src/services/apiSubscriptionsService.test.ts

@@ -1,73 +0,0 @@
-import { expect } from 'chai';
-
-import type { ApiSubscriptionRecord, ParseData } from '../types';
-import { ChainId } from '../types/enums';
-
-import '../configuration';
-import { parseDataFromApiSubscription } from './apiSubscriptionsService';
-import { parseStrategiesAutomatedPosition } from './strategiesService';
-
-describe('Feature: apiSubscriptionsService.ts', () => {
-  describe('When testing apiSubscriptionsService.parseDataFromApiSubscription', () => {
-    // same subscription as in strategiesService.test.ts, in the shape the automation API returns it
-    const record: ApiSubscriptionRecord = {
-      id: 379,
-      wallet: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-      wallet_type: 'safe',
-      is_enabled: true,
-      is_bundle: true,
-      strategy_or_bundle_id: 8,
-      strategy_ids: [34, 35],
-      sub_data_hash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-      trigger_data: [
-        '0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-      ],
-      sub_data: [
-        '0x0000000000000000000000000000000000000000000000001bc16d674ec80000',
-        '0x0000000000000000000000000000000000000000000000000000000000000001',
-        '0x0000000000000000000000000000000000000000000000000000000000000001',
-        '0x0000000000000000000000000000000000000000000000000000000000000000',
-      ],
-      block_number: 18015756,
-      additional_triggers: null,
-    };
-
-    const fromEvents: ParseData = {
-      chainId: ChainId.Ethereum,
-      blockNumber: 18015756,
-      subscriptionEventData: {
-        subId: '379',
-        proxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-        subHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-        subStruct: {
-          strategyOrBundleId: '8',
-          isBundle: true,
-          triggerData: [
-            '0x0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e00000000000000000000000000000000000000000000000019ac8532c27900000000000000000000000000000000000000000000000000000000000000000001',
-          ],
-          subData: record.sub_data,
-        },
-      },
-      strategiesSubsData: {
-        userProxy: '0x9cB7E19861665366011899d74E75d4F2A419aEeD',
-        isEnabled: true,
-        strategySubHash: '0xafa4d200be62f171b57b1ae0f4e8348d1ac3f6d0812ad6da74a2adae8037dde1',
-      },
-    };
-
-    it('Given an API record should return the same parse data as Subscribe event and SubStorage would', () => {
-      expect(parseDataFromApiSubscription(record, ChainId.Ethereum)).to.eql(fromEvents);
-    });
-
-    it('Given an API record the parsed position should match the one parsed from events', () => {
-      const fromApi = parseStrategiesAutomatedPosition(parseDataFromApiSubscription(record, ChainId.Ethereum));
-      expect(fromApi).to.not.equal(null);
-      expect(fromApi).to.eql(parseStrategiesAutomatedPosition(fromEvents));
-    });
-
-    it('Given a disabled record should keep it disabled', () => {
-      const parseData = parseDataFromApiSubscription({ ...record, is_enabled: false }, ChainId.Ethereum);
-      expect(parseData.strategiesSubsData.isEnabled).to.equal(false);
-    });
-  });
-});

package/src/services/apiSubscriptionsService.ts

@@ -1,33 +0,0 @@
-import type { ApiSubscriptionRecord, ParseData } from '../types';
-import type { ChainId } from '../types/enums';
-
-function addHexPrefix(value: string): string {
-  return value.startsWith('0x') ? value : `0x${value}`;
-}
-
-/**
- * @description Maps a subscription record returned by the automation API to the data
- * the parser expects from Subscribe events and SubStorage (trigger data is stored without 0x prefix)
- */
-export function parseDataFromApiSubscription(record: ApiSubscriptionRecord, chainId: ChainId): ParseData {
-  return {
-    chainId,
-    blockNumber: record.block_number,
-    subscriptionEventData: {
-      subId: record.id.toString(),
-      proxy: record.wallet,
-      subHash: record.sub_data_hash,
-      subStruct: {
-        strategyOrBundleId: record.strategy_or_bundle_id.toString(),
-        isBundle: record.is_bundle,
-        triggerData: record.trigger_data.map(addHexPrefix),
-        subData: record.sub_data.map(addHexPrefix),
-      },
-    },
-    strategiesSubsData: {
-      userProxy: record.wallet,
-      isEnabled: record.is_enabled,
-      strategySubHash: record.sub_data_hash,
-    },
-  };
-}