@defisaver/automation-sdk 3.1.4 → 3.2.0

package/.env

@@ -0,0 +1,5 @@
+# Used for testing
+RPC_1=https://eth-mainnet.g.alchemy.com/v2/4jm0fn2xvapd3pDpmdE8Y1rZKEp71U0Y
+RPC_10=https://opt-mainnet.g.alchemy.com/v2/4jm0fn2xvapd3pDpmdE8Y1rZKEp71U0Y
+RPC_42161=https://arb-mainnet.g.alchemy.com/v2/4jm0fn2xvapd3pDpmdE8Y1rZKEp71U0Y
+RPC_8453=https://base-mainnet.g.alchemy.com/v2/4jm0fn2xvapd3pDpmdE8Y1rZKEp71U0Y

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

@@ -1,24 +1,24 @@
 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 { StrategyModel, SubStorage } from '../../types/contracts/generated/SubStorage';
+import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
 interface IStrategiesAutomation extends Interfaces.Automation {
     chainId: ChainId;
-    providerFork: Web3;
+    providerFork?: Web3;
 }
 export default class StrategiesAutomation extends Automation {
     protected chainId: ChainId;
     protected web3: Web3;
-    protected web3Fork: Web3;
+    protected web3Fork?: Web3;
     protected subStorageContract: Contract.WithMeta<SubStorage>;
     protected subStorageContractFork: Contract.WithMeta<SubStorage> | null;
     constructor(args: IStrategiesAutomation);
     protected getEventFromSubStorage(event: string, options?: PastEventOptions): Promise<any[]>;
     protected getStrategiesSubs(subIds: number[], fromBlock?: BlockNumber): Promise<StrategyModel.StoredSubDataStructOutputStruct[]>;
-    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
-    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
+    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<Subscribe[]>;
+    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<UpdateData[]>;
     protected getParsedSubscriptions(parseData: ParseData): Position.Automated | null;
     /**
      * @description Removes expired Limit Order subscriptions

package/cjs/automation/private/StrategiesAutomation.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const es6_promise_pool_1 = __importDefault(require("es6-promise-pool"));
 const enums_1 = require("../../types/enums");
 const utils_1 = require("../../services/utils");
 const contractService_1 = require("../../services/contractService");
@@ -133,10 +134,10 @@ class StrategiesAutomation extends Automation_1.default {
     _getSubscriptions(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _options = Object.assign(Object.assign({}, (0, utils_1.addToObjectIf)((0, utils_1.isDefined)(options), options)), (0, utils_1.addToObjectIf)((0, utils_1.isDefined)(addresses), { filter: { proxy: addresses } }));
-            let subscriptionEvents = (yield this.getSubscriptionEventsFromSubStorage(_options)); // TODO PlaceholderType
+            let subscriptionEvents = yield this.getSubscriptionEventsFromSubStorage(_options);
             let subscriptions = [];
             if (subscriptionEvents) {
-                let strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId), _options.toBlock);
+                let strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => +e.returnValues.subId), _options.toBlock);
                 if (_options.enabledOnly) {
                     const filteredSubscriptionEvents = [];
                     strategiesSubs = strategiesSubs.filter((sub, index) => {
@@ -146,20 +147,28 @@ class StrategiesAutomation extends Automation_1.default {
                     });
                     subscriptionEvents = filteredSubscriptionEvents;
                 }
-                subscriptions = yield Promise.all(strategiesSubs.map((sub, index) => __awaiter(this, void 0, void 0, function* () {
+                const replaceSubWithUpdate = (index) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
+                    const sub = strategiesSubs[index];
                     let latestUpdate = subscriptionEvents[index].returnValues;
                     if (latestUpdate.subHash !== (sub === null || sub === void 0 ? void 0 : sub.strategySubHash)) {
                         const updates = yield this.getUpdateDataEventsFromSubStorage(Object.assign(Object.assign({}, (0, utils_1.addToObjectIf)(!!_options, _options)), { filter: { subId: latestUpdate.subId } }));
                         latestUpdate = Object.assign(Object.assign({}, latestUpdate), (_a = updates === null || updates === void 0 ? void 0 : updates[updates.length - 1]) === null || _a === void 0 ? void 0 : _a.returnValues);
                     }
-                    return this.getParsedSubscriptions({
+                    subscriptions.push(this.getParsedSubscriptions({
                         chainId: this.chainId,
                         blockNumber: subscriptionEvents[index].blockNumber,
                         subscriptionEventData: latestUpdate,
                         strategiesSubsData: sub,
-                    });
-                })));
+                    }));
+                });
+                const generatePromises = function* () {
+                    for (let index = 0; index < strategiesSubs.length; index++) {
+                        yield replaceSubWithUpdate(index);
+                    }
+                };
+                const pool = new es6_promise_pool_1.default(generatePromises, 50);
+                yield pool.start();
                 if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
                     subscriptions = this.mergeSubs(subscriptions);
                 }

package/cjs/automation/public/Strategies.test.d.ts

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

package/cjs/automation/public/Strategies.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_1 = __importDefault(require("web3"));
+require("../../configuration");
+const EthereumStrategies_1 = __importDefault(require("./EthereumStrategies"));
+const ArbitrumStrategies_1 = __importDefault(require("./ArbitrumStrategies"));
+const OptimismStrategies_1 = __importDefault(require("./OptimismStrategies"));
+const BaseStrategies_1 = __importDefault(require("./BaseStrategies"));
+require('dotenv').config({ path: '.env' });
+const Web3_1 = new web3_1.default(process.env.RPC_1);
+const Web3_42161 = new web3_1.default(process.env.RPC_42161);
+const Web3_10 = new web3_1.default(process.env.RPC_10);
+const Web3_8453 = new web3_1.default(process.env.RPC_8453);
+describe('Feature: StrategiesAutomation.ts', () => {
+    describe('Fetching subscriptions', () => {
+        it('can fetch subscriptions on Mainnet', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const ethStrategies = new EthereumStrategies_1.default({ provider: Web3_1 });
+                const subs = yield ethStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Arbitrum', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const arbiStrategies = new ArbitrumStrategies_1.default({ provider: Web3_42161 });
+                const subs = yield arbiStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Optimism', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const optimismStrategies = new OptimismStrategies_1.default({ provider: Web3_10 });
+                const subs = yield optimismStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Base', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const baseStrategies = new BaseStrategies_1.default({ provider: Web3_8453 });
+                const subs = yield baseStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+    });
+});

package/cjs/types/contracts/generated/SubStorage.d.ts

@@ -55,10 +55,6 @@ export type Subscribe = ContractEventLog<{
     proxy: string;
     subHash: string;
     subStruct: StrategyModel.StrategySubStructOutput;
-    0: string;
-    1: string;
-    2: string;
-    3: StrategyModel.StrategySubStructOutput;
 }>;
 export type UpdateData = ContractEventLog<{
     subId: string;

package/cjs/types/index.d.ts

@@ -69,7 +69,7 @@ export declare namespace Interfaces {
     }
     interface Automation {
         provider: Web3;
-        providerFork: Web3;
+        providerFork?: Web3;
     }
     interface LegacyAutomation<T extends BaseContract> {
         provider: Web3;

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

@@ -1,24 +1,24 @@
 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 { StrategyModel, SubStorage } from '../../types/contracts/generated/SubStorage';
+import type { StrategyModel, Subscribe, SubStorage, UpdateData } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import Automation from './Automation';
 interface IStrategiesAutomation extends Interfaces.Automation {
     chainId: ChainId;
-    providerFork: Web3;
+    providerFork?: Web3;
 }
 export default class StrategiesAutomation extends Automation {
     protected chainId: ChainId;
     protected web3: Web3;
-    protected web3Fork: Web3;
+    protected web3Fork?: Web3;
     protected subStorageContract: Contract.WithMeta<SubStorage>;
     protected subStorageContractFork: Contract.WithMeta<SubStorage> | null;
     constructor(args: IStrategiesAutomation);
     protected getEventFromSubStorage(event: string, options?: PastEventOptions): Promise<any[]>;
     protected getStrategiesSubs(subIds: number[], fromBlock?: BlockNumber): Promise<StrategyModel.StoredSubDataStructOutputStruct[]>;
-    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
-    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
+    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<Subscribe[]>;
+    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<UpdateData[]>;
     protected getParsedSubscriptions(parseData: ParseData): Position.Automated | null;
     /**
      * @description Removes expired Limit Order subscriptions

package/esm/automation/private/StrategiesAutomation.js

@@ -8,6 +8,7 @@ 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 { addToObjectIf, isDefined, isUndefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
@@ -128,10 +129,10 @@ export default class StrategiesAutomation extends Automation {
     _getSubscriptions(addresses, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _options = Object.assign(Object.assign({}, addToObjectIf(isDefined(options), options)), addToObjectIf(isDefined(addresses), { filter: { proxy: addresses } }));
-            let subscriptionEvents = (yield this.getSubscriptionEventsFromSubStorage(_options)); // TODO PlaceholderType
+            let subscriptionEvents = yield this.getSubscriptionEventsFromSubStorage(_options);
             let subscriptions = [];
             if (subscriptionEvents) {
-                let strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId), _options.toBlock);
+                let strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => +e.returnValues.subId), _options.toBlock);
                 if (_options.enabledOnly) {
                     const filteredSubscriptionEvents = [];
                     strategiesSubs = strategiesSubs.filter((sub, index) => {
@@ -141,20 +142,28 @@ export default class StrategiesAutomation extends Automation {
                     });
                     subscriptionEvents = filteredSubscriptionEvents;
                 }
-                subscriptions = yield Promise.all(strategiesSubs.map((sub, index) => __awaiter(this, void 0, void 0, function* () {
+                const replaceSubWithUpdate = (index) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
+                    const sub = strategiesSubs[index];
                     let latestUpdate = subscriptionEvents[index].returnValues;
                     if (latestUpdate.subHash !== (sub === null || sub === void 0 ? void 0 : sub.strategySubHash)) {
                         const updates = yield this.getUpdateDataEventsFromSubStorage(Object.assign(Object.assign({}, addToObjectIf(!!_options, _options)), { filter: { subId: latestUpdate.subId } }));
                         latestUpdate = Object.assign(Object.assign({}, latestUpdate), (_a = updates === null || updates === void 0 ? void 0 : updates[updates.length - 1]) === null || _a === void 0 ? void 0 : _a.returnValues);
                     }
-                    return this.getParsedSubscriptions({
+                    subscriptions.push(this.getParsedSubscriptions({
                         chainId: this.chainId,
                         blockNumber: subscriptionEvents[index].blockNumber,
                         subscriptionEventData: latestUpdate,
                         strategiesSubsData: sub,
-                    });
-                })));
+                    }));
+                });
+                const generatePromises = function* () {
+                    for (let index = 0; index < strategiesSubs.length; index++) {
+                        yield replaceSubWithUpdate(index);
+                    }
+                };
+                const pool = new PromisePool(generatePromises, 50);
+                yield pool.start();
                 if (options === null || options === void 0 ? void 0 : options.mergeSubs) {
                     subscriptions = this.mergeSubs(subscriptions);
                 }

package/esm/automation/public/Strategies.test.d.ts

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

package/esm/automation/public/Strategies.test.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Web3 from 'web3';
+import '../../configuration';
+import EthereumStrategies from './EthereumStrategies';
+import ArbitrumStrategies from './ArbitrumStrategies';
+import OptimismStrategies from './OptimismStrategies';
+import BaseStrategies from './BaseStrategies';
+require('dotenv').config({ path: '.env' });
+const Web3_1 = new Web3(process.env.RPC_1);
+const Web3_42161 = new Web3(process.env.RPC_42161);
+const Web3_10 = new Web3(process.env.RPC_10);
+const Web3_8453 = new Web3(process.env.RPC_8453);
+describe('Feature: StrategiesAutomation.ts', () => {
+    describe('Fetching subscriptions', () => {
+        it('can fetch subscriptions on Mainnet', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const ethStrategies = new EthereumStrategies({ provider: Web3_1 });
+                const subs = yield ethStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Arbitrum', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const arbiStrategies = new ArbitrumStrategies({ provider: Web3_42161 });
+                const subs = yield arbiStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Optimism', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const optimismStrategies = new OptimismStrategies({ provider: Web3_10 });
+                const subs = yield optimismStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+        it('can fetch subscriptions on Base', function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.timeout(120000);
+                const baseStrategies = new BaseStrategies({ provider: Web3_8453 });
+                const subs = yield baseStrategies.getSubscriptions({ mergeSubs: true });
+                console.log(subs.length);
+            });
+        });
+    });
+});

package/esm/types/contracts/generated/SubStorage.d.ts

@@ -55,10 +55,6 @@ export type Subscribe = ContractEventLog<{
     proxy: string;
     subHash: string;
     subStruct: StrategyModel.StrategySubStructOutput;
-    0: string;
-    1: string;
-    2: string;
-    3: StrategyModel.StrategySubStructOutput;
 }>;
 export type UpdateData = ContractEventLog<{
     subId: string;

package/esm/types/index.d.ts

@@ -69,7 +69,7 @@ export declare namespace Interfaces {
     }
     interface Automation {
         provider: Web3;
-        providerFork: Web3;
+        providerFork?: Web3;
     }
     interface LegacyAutomation<T extends BaseContract> {
         provider: Web3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "3.1.4",
+  "version": "3.2.0",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -29,6 +29,7 @@
     "@ethersproject/address": "^5.0.10",
     "@ethersproject/solidity": "^5.0.9",
     "decimal.js": "^10.4.3",
+    "es6-promise-pool": "^2.5.0",
     "lodash": "^4.17.21",
     "web3-eth-abi": "^1.10.2",
     "web3-utils": "^1.10.2"

package/src/automation/private/StrategiesAutomation.ts

@@ -1,11 +1,12 @@
 import Dec from 'decimal.js';
 import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
+import PromisePool from 'es6-promise-pool';
 import type {
   Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, PlaceholderType, BlockNumber,
 } from '../../types';
 import type {
-  StrategyModel, SubStorage,
+  StrategyModel, Subscribe, SubStorage, UpdateData,
 } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 import { Strategies, ProtocolIdentifiers } from '../../types/enums';
@@ -19,7 +20,7 @@ import Automation from './Automation';
 
 interface IStrategiesAutomation extends Interfaces.Automation {
   chainId: ChainId,
-  providerFork: Web3,
+  providerFork?: Web3,
 }
 
 export default class StrategiesAutomation extends Automation {
@@ -27,7 +28,7 @@ export default class StrategiesAutomation extends Automation {
 
   protected web3: Web3;
 
-  protected web3Fork: Web3;
+  protected web3Fork?: Web3;
 
   protected subStorageContract: Contract.WithMeta<SubStorage>;
 
@@ -77,13 +78,13 @@ export default class StrategiesAutomation extends Automation {
   }
 
   protected async getSubscriptionEventsFromSubStorage(options?: PastEventOptions) {
-    return this.getEventFromSubStorage('Subscribe', options);
+    return this.getEventFromSubStorage('Subscribe', options) as Promise<Subscribe[]>;
   }
 
   protected async getUpdateDataEventsFromSubStorage(options?: PastEventOptions) {
     const events = await this.getEventFromSubStorage('UpdateData', options);
     /** @dev - Some RPCs sort events differently */
-    return events.sort((a, b) => a.blockNumber - b.blockNumber);
+    return events.sort((a, b) => a.blockNumber - b.blockNumber) as UpdateData[];
   }
 
   protected getParsedSubscriptions(parseData: ParseData) {
@@ -183,13 +184,13 @@ export default class StrategiesAutomation extends Automation {
       ...addToObjectIf(isDefined(addresses), { filter: { proxy: addresses } }),
     } as SubscriptionOptions & PastEventOptions;
 
-    let subscriptionEvents = (await this.getSubscriptionEventsFromSubStorage(_options)) as PlaceholderType; // TODO PlaceholderType
+    let subscriptionEvents = await this.getSubscriptionEventsFromSubStorage(_options);
 
     let subscriptions: (Position.Automated | null)[] = [];
 
     if (subscriptionEvents) {
       let strategiesSubs = await this.getStrategiesSubs(
-        subscriptionEvents.map((e: { returnValues: { subId: number } }) => e.returnValues.subId), _options.toBlock,
+        subscriptionEvents.map((e) => +e.returnValues.subId), _options.toBlock,
       );
 
       if (_options.enabledOnly) {
@@ -203,7 +204,8 @@ export default class StrategiesAutomation extends Automation {
         subscriptionEvents = filteredSubscriptionEvents;
       }
 
-      subscriptions = await Promise.all(strategiesSubs.map(async (sub, index: number) => {
+      const replaceSubWithUpdate = async (index: number) => {
+        const sub = strategiesSubs[index];
         let latestUpdate = subscriptionEvents[index].returnValues;
 
         if (latestUpdate.subHash !== sub?.strategySubHash) {
@@ -216,13 +218,23 @@ export default class StrategiesAutomation extends Automation {
             ...updates?.[updates.length - 1]?.returnValues,
           };
         }
-        return this.getParsedSubscriptions({
-          chainId: this.chainId,
-          blockNumber: subscriptionEvents[index].blockNumber,
-          subscriptionEventData: latestUpdate,
-          strategiesSubsData: sub,
-        });
-      }));
+        subscriptions.push(
+          this.getParsedSubscriptions({
+            chainId: this.chainId,
+            blockNumber: subscriptionEvents[index].blockNumber,
+            subscriptionEventData: latestUpdate,
+            strategiesSubsData: sub,
+          }),
+        );
+      };
+
+      const generatePromises = function* () {
+        for (let index = 0; index < strategiesSubs.length; index++) {
+          yield replaceSubWithUpdate(index);
+        }
+      };
+      const pool = new PromisePool(generatePromises as any, 50);
+      await pool.start();
 
       if (options?.mergeSubs) {
         subscriptions = this.mergeSubs(subscriptions);

package/src/automation/public/Strategies.test.ts

@@ -0,0 +1,49 @@
+import Web3 from 'web3';
+import { expect } from 'chai';
+
+import {ChainId} from '../../types/enums';
+
+import '../../configuration';
+import EthereumStrategies from './EthereumStrategies';
+import ArbitrumStrategies from './ArbitrumStrategies';
+import OptimismStrategies from './OptimismStrategies';
+import BaseStrategies from './BaseStrategies';
+
+require('dotenv').config({ path: '.env' });
+
+const Web3_1 = new Web3(process.env.RPC_1!);
+const Web3_42161 = new Web3(process.env.RPC_42161!);
+const Web3_10 = new Web3(process.env.RPC_10!);
+const Web3_8453 = new Web3(process.env.RPC_8453!);
+
+describe('Feature: StrategiesAutomation.ts', () => {
+  describe('Fetching subscriptions', () => {
+    it('can fetch subscriptions on Mainnet', async function () {
+      this.timeout(120000);
+      const ethStrategies = new EthereumStrategies({provider: Web3_1});
+      const subs = await ethStrategies.getSubscriptions({mergeSubs: true})
+      console.log(subs.length);
+    });
+
+    it('can fetch subscriptions on Arbitrum', async function () {
+      this.timeout(120000);
+      const arbiStrategies = new ArbitrumStrategies({provider: Web3_42161});
+      const subs = await arbiStrategies.getSubscriptions({mergeSubs: true})
+      console.log(subs.length);
+    });
+
+    it('can fetch subscriptions on Optimism', async function () {
+      this.timeout(120000);
+      const optimismStrategies = new OptimismStrategies({provider: Web3_10});
+      const subs = await optimismStrategies.getSubscriptions({mergeSubs: true})
+      console.log(subs.length);
+    });
+
+    it('can fetch subscriptions on Base', async function () {
+      this.timeout(120000);
+      const baseStrategies = new BaseStrategies({provider: Web3_8453});
+      const subs = await baseStrategies.getSubscriptions({mergeSubs: true})
+      console.log(subs.length);
+    });
+  });
+});

package/src/types/index.ts

@@ -90,7 +90,7 @@ export declare namespace Interfaces {
 
   interface Automation {
     provider: Web3,
-    providerFork: Web3,
+    providerFork?: Web3,
   }
   interface LegacyAutomation<T extends BaseContract> {
     provider: Web3,