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

package/cjs/automation/private/StrategiesAutomation.js

@@ -21,6 +21,18 @@ const ethereumService_1 = require("../../services/ethereumService");
 const strategiesService_1 = require("../../services/strategiesService");
 const apiSubscriptionsService_1 = require("../../services/apiSubscriptionsService");
 const Automation_1 = __importDefault(require("./Automation"));
+/**
+ * Adds the backend flags to a parsed position. A repay or boost half of a leverage management pair also gets its
+ * own invalid flag in specific, next to repayEnabled and boostEnabled, so it survives merging.
+ */
+const withApiFlags = (position, record) => {
+    const specific = Object.assign({}, position.specific);
+    if ((0, utils_1.isDefined)(specific.mergeWithId))
+        specific.repayInvalid = record.invalid;
+    if ((0, utils_1.isDefined)(specific.mergeId))
+        specific.boostInvalid = record.invalid;
+    return Object.assign(Object.assign({}, position), { invalid: record.invalid, specific: specific });
+};
 class StrategiesAutomation extends Automation_1.default {
     constructor(args) {
         super();
@@ -129,9 +141,7 @@ class StrategiesAutomation extends Automation_1.default {
                 mergeExtension.splice(mergePairIndex, 1);
                 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 }), (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) }));
+                    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.invalid), { invalid: !!mergePair.invalid && !!current.invalid })), { specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
             }
             else {
                 subscriptions.push(Object.assign(Object.assign({}, current), { subIds: [current.subId] }));
@@ -199,7 +209,7 @@ class StrategiesAutomation extends Automation_1.default {
         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 });
+            return position && withApiFlags(position, record);
         });
         if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
             subscriptions = this.mergeSubs(subscriptions);

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

@@ -724,20 +724,31 @@ describe('Feature: StrategiesAutomation.ts', () => {
             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]);
+        it('Given API records should return parsed positions carrying the invalid flags', () => {
+            var _a, _b;
+            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, Object.assign(Object.assign({}, boost), { invalid: true })]);
             (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]);
+            (0, chai_1.expect)(positions.map((p) => p === null || p === void 0 ? void 0 : p.invalid)).to.eql([false, true]);
+            (0, chai_1.expect)(((_a = positions[0]) === null || _a === void 0 ? void 0 : _a.specific).repayInvalid).to.equal(false);
+            (0, chai_1.expect)(((_b = positions[1]) === null || _b === void 0 ? void 0 : _b.specific).boostInvalid).to.equal(true);
         });
-        it('Given mergeSubs option should merge the repay and boost pair and keep the active status', () => {
+        it('Given a merged pair should keep each half\'s invalid flag and mark the pair invalid only when both are', () => {
             var _a, _b, _c;
+            const oneInvalid = strategiesAutomation.parseSubscriptionsFromApi([repay, Object.assign(Object.assign({}, boost), { invalid: true })], { mergeSubs: true });
+            (0, chai_1.expect)(oneInvalid).to.have.length(1);
+            (0, chai_1.expect)((_a = oneInvalid[0]) === null || _a === void 0 ? void 0 : _a.invalid).to.equal(false);
+            (0, chai_1.expect)((_b = oneInvalid[0]) === null || _b === void 0 ? void 0 : _b.specific).to.include({ repayInvalid: false, boostInvalid: true });
+            const bothInvalid = strategiesAutomation.parseSubscriptionsFromApi([Object.assign(Object.assign({}, repay), { invalid: true }), Object.assign(Object.assign({}, boost), { invalid: true })], { mergeSubs: true });
+            (0, chai_1.expect)((_c = bothInvalid[0]) === null || _c === void 0 ? void 0 : _c.invalid).to.equal(true);
+        });
+        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);
-            (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 });

package/cjs/types/index.d.ts

@@ -122,6 +122,9 @@ export declare namespace Position {
             triggerBoostRatio?: number;
             targetBoostRatio?: number;
             boostEnabled?: boolean;
+            /** Set only for subscriptions parsed from the automation API: the backend marked that half invalid */
+            repayInvalid?: boolean;
+            boostInvalid?: boolean;
         }
         interface CloseOnPrice extends Base {
             price: string;
@@ -255,8 +258,8 @@ export declare namespace Position {
         subId: number;
         subIds?: number[];
         isEnabled?: boolean;
-        /** Set only for subscriptions parsed from the automation API */
-        status?: SubscriptionStatus;
+        /** Set only for subscriptions parsed from the automation API: the backend will not execute this subscription */
+        invalid?: boolean;
         subHash: string;
         blockNumber: BlockNumber;
         protocol: Interfaces.Protocol;

package/esm/automation/private/StrategiesAutomation.js

@@ -9,13 +9,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import PromisePool from 'es6-promise-pool';
-import { Strategies, ProtocolIdentifiers, SubscriptionStatus } from '../../types/enums';
+import { Strategies, ProtocolIdentifiers } 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';
+/**
+ * Adds the backend flags to a parsed position. A repay or boost half of a leverage management pair also gets its
+ * own invalid flag in specific, next to repayEnabled and boostEnabled, so it survives merging.
+ */
+const withApiFlags = (position, record) => {
+    const specific = Object.assign({}, position.specific);
+    if (isDefined(specific.mergeWithId))
+        specific.repayInvalid = record.invalid;
+    if (isDefined(specific.mergeId))
+        specific.boostInvalid = record.invalid;
+    return Object.assign(Object.assign({}, position), { invalid: record.invalid, specific: specific });
+};
 export default class StrategiesAutomation extends Automation {
     constructor(args) {
         super();
@@ -124,9 +136,7 @@ export default class StrategiesAutomation extends Automation {
                 mergeExtension.splice(mergePairIndex, 1);
                 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 }), addToObjectIf(isDefined(current.status), {
-                    status: mergePair.status === SubscriptionStatus.Active ? SubscriptionStatus.Active : current.status,
-                })), { 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.invalid), { invalid: !!mergePair.invalid && !!current.invalid })), { specific: Object.assign(Object.assign({}, mergePair.specific), current.specific) }));
             }
             else {
                 subscriptions.push(Object.assign(Object.assign({}, current), { subIds: [current.subId] }));
@@ -194,7 +204,7 @@ export default class StrategiesAutomation extends Automation {
         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 });
+            return position && withApiFlags(position, record);
         });
         if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
             subscriptions = this.mergeSubs(subscriptions);

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

@@ -719,20 +719,31 @@ describe('Feature: StrategiesAutomation.ts', () => {
             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]);
+        it('Given API records should return parsed positions carrying the invalid flags', () => {
+            var _a, _b;
+            const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, Object.assign(Object.assign({}, boost), { invalid: true })]);
             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]);
+            expect(positions.map((p) => p === null || p === void 0 ? void 0 : p.invalid)).to.eql([false, true]);
+            expect(((_a = positions[0]) === null || _a === void 0 ? void 0 : _a.specific).repayInvalid).to.equal(false);
+            expect(((_b = positions[1]) === null || _b === void 0 ? void 0 : _b.specific).boostInvalid).to.equal(true);
         });
-        it('Given mergeSubs option should merge the repay and boost pair and keep the active status', () => {
+        it('Given a merged pair should keep each half\'s invalid flag and mark the pair invalid only when both are', () => {
             var _a, _b, _c;
+            const oneInvalid = strategiesAutomation.parseSubscriptionsFromApi([repay, Object.assign(Object.assign({}, boost), { invalid: true })], { mergeSubs: true });
+            expect(oneInvalid).to.have.length(1);
+            expect((_a = oneInvalid[0]) === null || _a === void 0 ? void 0 : _a.invalid).to.equal(false);
+            expect((_b = oneInvalid[0]) === null || _b === void 0 ? void 0 : _b.specific).to.include({ repayInvalid: false, boostInvalid: true });
+            const bothInvalid = strategiesAutomation.parseSubscriptionsFromApi([Object.assign(Object.assign({}, repay), { invalid: true }), Object.assign(Object.assign({}, boost), { invalid: true })], { mergeSubs: true });
+            expect((_c = bothInvalid[0]) === null || _c === void 0 ? void 0 : _c.invalid).to.equal(true);
+        });
+        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);
-            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 });

package/esm/types/index.d.ts

@@ -122,6 +122,9 @@ export declare namespace Position {
             triggerBoostRatio?: number;
             targetBoostRatio?: number;
             boostEnabled?: boolean;
+            /** Set only for subscriptions parsed from the automation API: the backend marked that half invalid */
+            repayInvalid?: boolean;
+            boostInvalid?: boolean;
         }
         interface CloseOnPrice extends Base {
             price: string;
@@ -255,8 +258,8 @@ export declare namespace Position {
         subId: number;
         subIds?: number[];
         isEnabled?: boolean;
-        /** Set only for subscriptions parsed from the automation API */
-        status?: SubscriptionStatus;
+        /** Set only for subscriptions parsed from the automation API: the backend will not execute this subscription */
+        invalid?: boolean;
         subHash: string;
         blockNumber: BlockNumber;
         protocol: Interfaces.Protocol;

package/package.json

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

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

@@ -743,20 +743,34 @@ describe('Feature: StrategiesAutomation.ts', () => {
       trigger_data: ['0000000000000000000000009cb7e19861665366011899d74e75d4f2a419aeed0000000000000000000000002f39d218133afab8f2b819b1066c7e434ad94e9e0000000000000000000000000000000000000000000000002386f26fc10000000000000000000000000000000000000000000000000000000000000000000000'],
     };
 
-    it('Given API records should return parsed positions carrying the API status', () => {
-      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, boost]);
+    it('Given API records should return parsed positions carrying the invalid flags', () => {
+      const positions = strategiesAutomation.parseSubscriptionsFromApi([repay, { ...boost, invalid: true }]);
       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]);
+      expect(positions.map((p) => p?.invalid)).to.eql([false, true]);
+      expect((positions[0]?.specific as { repayInvalid?: boolean }).repayInvalid).to.equal(false);
+      expect((positions[1]?.specific as { boostInvalid?: boolean }).boostInvalid).to.equal(true);
     });
 
-    it('Given mergeSubs option should merge the repay and boost pair and keep the active status', () => {
+    it('Given a merged pair should keep each half\'s invalid flag and mark the pair invalid only when both are', () => {
+      const oneInvalid = strategiesAutomation.parseSubscriptionsFromApi([repay, { ...boost, invalid: true }], { mergeSubs: true });
+      expect(oneInvalid).to.have.length(1);
+      expect(oneInvalid[0]?.invalid).to.equal(false);
+      expect(oneInvalid[0]?.specific).to.include({ repayInvalid: false, boostInvalid: true });
+
+      const bothInvalid = strategiesAutomation.parseSubscriptionsFromApi(
+        [{ ...repay, invalid: true }, { ...boost, invalid: true }],
+        { mergeSubs: true },
+      );
+      expect(bothInvalid[0]?.invalid).to.equal(true);
+    });
+
+    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);
-      expect(positions[0]?.status).to.equal(SubscriptionStatus.Active);
     });
 
     it('Given enabledOnly option should drop disabled records before parsing', () => {

package/src/automation/private/StrategiesAutomation.ts

@@ -10,7 +10,7 @@ import type {
   StrategyModel, Subscribe, SubStorage, UpdateData,
 } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
-import { Strategies, ProtocolIdentifiers, SubscriptionStatus } from '../../types/enums';
+import { Strategies, ProtocolIdentifiers } from '../../types/enums';
 
 import { addToObjectIf, isDefined, isUndefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
@@ -25,6 +25,17 @@ interface IStrategiesAutomation extends Interfaces.Automation {
   providerFork?: Web3,
 }
 
+/**
+ * Adds the backend flags to a parsed position. A repay or boost half of a leverage management pair also gets its
+ * own invalid flag in specific, next to repayEnabled and boostEnabled, so it survives merging.
+ */
+const withApiFlags = (position: Position.Automated, record: ApiSubscriptionRecord): Position.Automated => {
+  const specific = { ...position.specific } as Position.Specific.RatioProtection;
+  if (isDefined(specific.mergeWithId)) specific.repayInvalid = record.invalid;
+  if (isDefined(specific.mergeId)) specific.boostInvalid = record.invalid;
+  return { ...position, invalid: record.invalid, specific: specific as Position.SpecificAny };
+};
+
 export default class StrategiesAutomation extends Automation {
   protected chainId: ChainId;
 
@@ -169,10 +180,8 @@ 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,
-          }),
+          // set only for subscriptions parsed from the automation API, per half flags live in specific
+          ...addToObjectIf(isDefined(current.invalid), { invalid: !!mergePair.invalid && !!current.invalid }),
           specific: {
             ...mergePair.specific,
             ...current.specific,
@@ -273,7 +282,7 @@ export default class StrategiesAutomation extends Automation {
 
     let subscriptions: (Position.Automated | null)[] = filtered.map((record) => {
       const position = this.getParsedSubscriptions(parseDataFromApiSubscription(record, this.chainId));
-      return position && { ...position, status: record.status };
+      return position && withApiFlags(position, record);
     });
 
     if (options?.mergeSubs) {

package/src/types/index.ts

@@ -150,6 +150,9 @@ export declare namespace Position {
       triggerBoostRatio?: number,
       targetBoostRatio?: number,
       boostEnabled?: boolean,
+      /** Set only for subscriptions parsed from the automation API: the backend marked that half invalid */
+      repayInvalid?: boolean,
+      boostInvalid?: boolean,
     }
     interface CloseOnPrice extends Base {
       price: string,
@@ -320,8 +323,8 @@ export declare namespace Position {
     subId: number,
     subIds?: number[],
     isEnabled?: boolean,
-    /** Set only for subscriptions parsed from the automation API */
-    status?: SubscriptionStatus,
+    /** Set only for subscriptions parsed from the automation API: the backend will not execute this subscription */
+    invalid?: boolean,
     subHash: string,
     blockNumber: BlockNumber,
     protocol: Interfaces.Protocol,