@defisaver/automation-sdk 3.3.18-spark-eoa-v2-dev → 3.3.19-sub-fetching-dev

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 } from '../../types';
+import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber, ApiSubscriptionRecord } from '../../types';
 import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
@@ -30,6 +30,10 @@ 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,6 +19,7 @@ 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) {
@@ -126,9 +127,11 @@ class StrategiesAutomation extends Automation_1.default {
             if (mergePairIndex !== -1) {
                 const mergePair = mergeExtension[mergePairIndex];
                 mergeExtension.splice(mergePairIndex, 1);
-                subscriptions.push(Object.assign(Object.assign(Object.assign({}, mergePair), current), { 
+                subscriptions.push(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, mergePair), current), { 
                     // @ts-ignore
-                    blockNumber: decimal_js_1.default.max(mergePair.blockNumber, current.blockNumber).toNumber(), subIds: [current.subId, mergePair.subId], isEnabled: mergePair.isEnabled || current.isEnabled, specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
+                    blockNumber: decimal_js_1.default.max(mergePair.blockNumber, current.blockNumber).toNumber(), subIds: [current.subId, mergePair.subId], isEnabled: mergePair.isEnabled || current.isEnabled }), (0, utils_1.addToObjectIf)((0, utils_1.isDefined)(current.status), {
+                    status: mergePair.status === enums_1.SubscriptionStatus.Active ? enums_1.SubscriptionStatus.Active : current.status,
+                })), { specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
             }
             else {
                 subscriptions.push(Object.assign(Object.assign({}, current), { subIds: [current.subId] }));
@@ -189,6 +192,20 @@ 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) => {
+            const position = this.getParsedSubscriptions((0, apiSubscriptionsService_1.parseDataFromApiSubscription)(record, this.chainId));
+            return position && Object.assign(Object.assign({}, position), { status: record.status });
+        });
+        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,4 +693,59 @@ 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,
+            invalid: false,
+            status: enums_1.SubscriptionStatus.Active,
+            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, status: enums_1.SubscriptionStatus.Disabled, strategy_or_bundle_id: 9, sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111', trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'] });
+        it('Given API records should return parsed positions carrying the API status', () => {
+            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.status)).to.eql([enums_1.SubscriptionStatus.Active, enums_1.SubscriptionStatus.Disabled]);
+            (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 and keep the active status', () => {
+            var _a, _b, _c;
+            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);
+            (0, chai_1.expect)((_c = positions[0]) === null || _c === void 0 ? void 0 : _c.status).to.equal(enums_1.SubscriptionStatus.Active);
+        });
+        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/apiSubscriptionsService.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,33 @@
+"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

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

package/cjs/services/apiSubscriptionsService.test.js

@@ -0,0 +1,69 @@
+"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,
+            invalid: false,
+            status: enums_1.SubscriptionStatus.Active,
+            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/cjs/services/strategiesService.test.js

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

package/cjs/types/enums.d.ts

@@ -4,6 +4,12 @@ export declare enum ChainId {
     Arbitrum = 42161,
     Base = 8453
 }
+export declare enum SubscriptionStatus {
+    Active = "active",
+    Disabled = "disabled",
+    Finished = "finished",
+    Invalid = "invalid"
+}
 export declare enum RatioState {
     OVER = 0,
     UNDER = 1

package/cjs/types/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bundles = exports.Strategies = exports.ProtocolIdentifiers = exports.CloseToAssetType = exports.CloseStrategyType = exports.DebtActionType = exports.CollActionType = exports.BundleProtocols = exports.OrderType = exports.RatioState = exports.ChainId = void 0;
+exports.Bundles = exports.Strategies = exports.ProtocolIdentifiers = exports.CloseToAssetType = exports.CloseStrategyType = exports.DebtActionType = exports.CollActionType = exports.BundleProtocols = exports.OrderType = exports.RatioState = exports.SubscriptionStatus = exports.ChainId = void 0;
 var ChainId;
 (function (ChainId) {
     ChainId[ChainId["Ethereum"] = 1] = "Ethereum";
@@ -8,6 +8,13 @@ var ChainId;
     ChainId[ChainId["Arbitrum"] = 42161] = "Arbitrum";
     ChainId[ChainId["Base"] = 8453] = "Base";
 })(ChainId = exports.ChainId || (exports.ChainId = {}));
+var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["Active"] = "active";
+    SubscriptionStatus["Disabled"] = "disabled";
+    SubscriptionStatus["Finished"] = "finished";
+    SubscriptionStatus["Invalid"] = "invalid";
+})(SubscriptionStatus = exports.SubscriptionStatus || (exports.SubscriptionStatus = {}));
 var RatioState;
 (function (RatioState) {
     RatioState[RatioState["OVER"] = 0] = "OVER";

package/cjs/types/index.d.ts

@@ -1,8 +1,8 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
-import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
+import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType, SubscriptionStatus } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
 export type BlockNumber = BlockType;
@@ -53,6 +53,23 @@ 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;
+    invalid: boolean;
+    status: SubscriptionStatus;
+    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;
@@ -238,6 +255,8 @@ export declare namespace Position {
         subId: number;
         subIds?: number[];
         isEnabled?: boolean;
+        /** Set only for subscriptions parsed from the automation API */
+        status?: SubscriptionStatus;
         subHash: string;
         blockNumber: BlockNumber;
         protocol: Interfaces.Protocol;
@@ -291,10 +310,17 @@ 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: Subscribe['returnValues'];
+    subscriptionEventData: SubscriptionEventData;
     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 } from '../../types';
+import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, BlockNumber, ApiSubscriptionRecord } from '../../types';
 import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
@@ -30,6 +30,10 @@ 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

@@ -9,11 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import PromisePool from 'es6-promise-pool';
-import { Strategies, ProtocolIdentifiers } from '../../types/enums';
+import { Strategies, ProtocolIdentifiers, SubscriptionStatus } from '../../types/enums';
 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) {
@@ -121,9 +122,11 @@ export default class StrategiesAutomation extends Automation {
             if (mergePairIndex !== -1) {
                 const mergePair = mergeExtension[mergePairIndex];
                 mergeExtension.splice(mergePairIndex, 1);
-                subscriptions.push(Object.assign(Object.assign(Object.assign({}, mergePair), current), { 
+                subscriptions.push(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, mergePair), current), { 
                     // @ts-ignore
-                    blockNumber: Dec.max(mergePair.blockNumber, current.blockNumber).toNumber(), subIds: [current.subId, mergePair.subId], isEnabled: mergePair.isEnabled || current.isEnabled, specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
+                    blockNumber: Dec.max(mergePair.blockNumber, current.blockNumber).toNumber(), subIds: [current.subId, mergePair.subId], isEnabled: mergePair.isEnabled || current.isEnabled }), addToObjectIf(isDefined(current.status), {
+                    status: mergePair.status === SubscriptionStatus.Active ? SubscriptionStatus.Active : current.status,
+                })), { specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
             }
             else {
                 subscriptions.push(Object.assign(Object.assign({}, current), { subIds: [current.subId] }));
@@ -184,6 +187,20 @@ 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) => {
+            const position = this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId));
+            return position && Object.assign(Object.assign({}, position), { status: record.status });
+        });
+        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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Web3 from 'web3';
 import { expect } from 'chai';
-import { ChainId } from '../../types/enums';
+import { ChainId, SubscriptionStatus } from '../../types/enums';
 import '../../configuration';
 import StrategiesAutomation from './StrategiesAutomation';
 require('dotenv').config({ path: '.env' });
@@ -688,4 +688,59 @@ 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,
+            invalid: false,
+            status: SubscriptionStatus.Active,
+            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, status: SubscriptionStatus.Disabled, strategy_or_bundle_id: 9, sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111', trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'] });
+        it('Given API records should return parsed positions carrying the API status', () => {
+            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.status)).to.eql([SubscriptionStatus.Active, SubscriptionStatus.Disabled]);
+            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 and keep the active status', () => {
+            var _a, _b, _c;
+            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);
+            expect((_c = positions[0]) === null || _c === void 0 ? void 0 : _c.status).to.equal(SubscriptionStatus.Active);
+        });
+        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/apiSubscriptionsService.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,29 @@
+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

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

package/esm/services/apiSubscriptionsService.test.js

@@ -0,0 +1,67 @@
+import { expect } from 'chai';
+import { ChainId, SubscriptionStatus } 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,
+            invalid: false,
+            status: SubscriptionStatus.Active,
+            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/esm/services/strategiesService.test.js

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

package/esm/types/enums.d.ts

@@ -4,6 +4,12 @@ export declare enum ChainId {
     Arbitrum = 42161,
     Base = 8453
 }
+export declare enum SubscriptionStatus {
+    Active = "active",
+    Disabled = "disabled",
+    Finished = "finished",
+    Invalid = "invalid"
+}
 export declare enum RatioState {
     OVER = 0,
     UNDER = 1

package/esm/types/enums.js

@@ -5,6 +5,13 @@ export var ChainId;
     ChainId[ChainId["Arbitrum"] = 42161] = "Arbitrum";
     ChainId[ChainId["Base"] = 8453] = "Base";
 })(ChainId || (ChainId = {}));
+export var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["Active"] = "active";
+    SubscriptionStatus["Disabled"] = "disabled";
+    SubscriptionStatus["Finished"] = "finished";
+    SubscriptionStatus["Invalid"] = "invalid";
+})(SubscriptionStatus || (SubscriptionStatus = {}));
 export var RatioState;
 (function (RatioState) {
     RatioState[RatioState["OVER"] = 0] = "OVER";

package/esm/types/index.d.ts

@@ -1,8 +1,8 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
-import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType } from './enums';
+import type { StrategyModel } from './contracts/generated/SubStorage';
+import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState, CloseToAssetType, SubscriptionStatus } from './enums';
 export type PlaceholderType = any;
 export type EthereumAddress = string;
 export type BlockNumber = BlockType;
@@ -53,6 +53,23 @@ 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;
+    invalid: boolean;
+    status: SubscriptionStatus;
+    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;
@@ -238,6 +255,8 @@ export declare namespace Position {
         subId: number;
         subIds?: number[];
         isEnabled?: boolean;
+        /** Set only for subscriptions parsed from the automation API */
+        status?: SubscriptionStatus;
         subHash: string;
         blockNumber: BlockNumber;
         protocol: Interfaces.Protocol;
@@ -291,10 +310,17 @@ 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: Subscribe['returnValues'];
+    subscriptionEventData: SubscriptionEventData;
     strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct;
 }
 type MapToProtocolVersion<T> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.3.18-spark-eoa-v2-dev",
+  "version": "3.3.19-sub-fetching-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

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

@@ -1,7 +1,8 @@
 import Web3 from 'web3';
 import { expect } from 'chai';
 
-import {ChainId} from '../../types/enums';
+import { ChainId, SubscriptionStatus } from '../../types/enums';
+import type { ApiSubscriptionRecord } from '../../types';
 
 import '../../configuration';
 import StrategiesAutomation from './StrategiesAutomation';
@@ -700,4 +701,72 @@ 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,
+      invalid: false,
+      status: SubscriptionStatus.Active,
+      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,
+      status: SubscriptionStatus.Disabled,
+      strategy_or_bundle_id: 9,
+      sub_data_hash: '0x1111111111111111111111111111111111111111111111111111111111111111',
+      trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'],
+    };
+
+    it('Given API records should return parsed positions carrying the API status', () => {
+      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?.status)).to.eql([SubscriptionStatus.Active, SubscriptionStatus.Disabled]);
+      expect(positions.map((p) => p?.isEnabled)).to.eql([true, false]);
+    });
+
+    it('Given mergeSubs option should merge the repay and boost pair and keep the active status', () => {
+      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);
+      expect(positions[0]?.status).to.equal(SubscriptionStatus.Active);
+    });
+
+    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,17 +4,19 @@ 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,
 } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
-import { Strategies, ProtocolIdentifiers } from '../../types/enums';
+import { Strategies, ProtocolIdentifiers, SubscriptionStatus } from '../../types/enums';
 
 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';
 
@@ -167,6 +169,10 @@ export default class StrategiesAutomation extends Automation {
           blockNumber: Dec.max(mergePair.blockNumber, current.blockNumber).toNumber(),
           subIds: [current.subId, mergePair.subId],
           isEnabled: mergePair.isEnabled || current.isEnabled,
+          // status is set only for subscriptions parsed from the automation API
+          ...addToObjectIf(isDefined(current.status), {
+            status: mergePair.status === SubscriptionStatus.Active ? SubscriptionStatus.Active : current.status,
+          }),
           specific: {
             ...mergePair.specific,
             ...current.specific,
@@ -259,6 +265,24 @@ 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: (Position.Automated | null)[] = filtered.map((record) => {
+      const position = this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId));
+      return position && { ...position, status: record.status };
+    });
+
+    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/apiSubscriptionsService.test.ts

@@ -0,0 +1,75 @@
+import { expect } from 'chai';
+
+import type { ApiSubscriptionRecord, ParseData } from '../types';
+import { ChainId, SubscriptionStatus } 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,
+      invalid: false,
+      status: SubscriptionStatus.Active,
+      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

@@ -0,0 +1,33 @@
+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,
+    },
+  };
+}

package/src/services/strategiesService.test.ts

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

package/src/types/enums.ts

@@ -5,6 +5,13 @@ export enum ChainId {
   Base = 8453,
 }
 
+export enum SubscriptionStatus {
+  Active = 'active',
+  Disabled = 'disabled',
+  Finished = 'finished',
+  Invalid = 'invalid',
+}
+
 export enum RatioState {
   OVER = 0,
   UNDER = 1,

package/src/types/index.ts

@@ -1,11 +1,12 @@
 import type Web3 from 'web3';
 import type { AbiItem } from 'web3-utils';
 import type { BaseContract, BlockType } from './contracts/generated/types';
-import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
+import type { StrategyModel } from './contracts/generated/SubStorage';
 import type {
   ChainId, Strategies, Bundles, ProtocolIdentifiers,
   RatioState,
   CloseToAssetType,
+  SubscriptionStatus,
 } from './enums';
 
 export type PlaceholderType = any; // TODO - fix any types
@@ -72,6 +73,24 @@ 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,
+  invalid: boolean,
+  status: SubscriptionStatus,
+  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,
@@ -301,6 +320,8 @@ export declare namespace Position {
     subId: number,
     subIds?: number[],
     isEnabled?: boolean,
+    /** Set only for subscriptions parsed from the automation API */
+    status?: SubscriptionStatus,
     subHash: string,
     blockNumber: BlockNumber,
     protocol: Interfaces.Protocol,
@@ -369,10 +390,18 @@ 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: Subscribe['returnValues']
+  subscriptionEventData: SubscriptionEventData,
   strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct,
 }