@defisaver/automation-sdk 1.2.2 → 1.2.3

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

@@ -6,16 +6,19 @@ import Automation from './Automation';
 import type { ChainId } from '../../types/enums';
 interface IStrategiesAutomation extends Interfaces.Automation {
     chainId: ChainId;
+    providerFork: Web3;
 }
 export default class StrategiesAutomation extends Automation {
     protected chainId: ChainId;
     protected web3: 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<import("web3-eth-contract").EventData[]>;
+    protected getEventFromSubStorage(event: string, options?: PastEventOptions): Promise<any[]>;
     protected getStrategiesSubs(subIds: number[]): Promise<StrategyModel.StoredSubDataStructOutputStruct[]>;
-    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<import("web3-eth-contract").EventData[]>;
-    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<import("web3-eth-contract").EventData[]>;
+    protected getSubscriptionEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
+    protected getUpdateDataEventsFromSubStorage(options?: PastEventOptions): Promise<any[]>;
     protected getParsedSubscriptions(parseData: ParseData): Position.Automated | null;
     protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
     getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;

package/esm/automation/private/StrategiesAutomation.js

@@ -17,24 +17,37 @@ export default class StrategiesAutomation extends Automation {
     constructor(args) {
         super();
         this.web3 = args.provider;
+        this.web3Fork = args.providerFork;
         this.chainId = args.chainId;
         this.subStorageContract = makeSubStorageContract(this.web3, this.chainId);
+        this.subStorageContractFork = this.web3Fork ? makeSubStorageContract(this.web3Fork, this.chainId) : null;
         this.assert();
     }
     getEventFromSubStorage(event, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return getEventsFromContract(this.subStorageContract, event, options);
+            return getEventsFromContract(this.subStorageContract, this.subStorageContractFork, event, options);
         });
     }
     getStrategiesSubs(subIds) {
         return __awaiter(this, void 0, void 0, function* () {
-            const subStorageContract = this.subStorageContract;
-            const defaultOptions = {
-                target: subStorageContract.address,
-                abiItem: getAbiItem(subStorageContract.abi, 'strategiesSubs'),
-            };
-            const multicallCalls = subIds.map((subId) => (Object.assign(Object.assign({}, defaultOptions), { params: [subId] })));
-            return multicall(this.web3, this.chainId, multicallCalls);
+            let options;
+            let web3;
+            if (this.web3Fork && this.subStorageContractFork) {
+                options = {
+                    target: this.subStorageContractFork.address,
+                    abiItem: getAbiItem(this.subStorageContractFork.abi, 'strategiesSubs'),
+                };
+                web3 = this.web3Fork;
+            }
+            else {
+                options = {
+                    target: this.subStorageContract.address,
+                    abiItem: getAbiItem(this.subStorageContract.abi, 'strategiesSubs'),
+                };
+                web3 = this.web3;
+            }
+            const multicallCalls = subIds.map((subId) => (Object.assign(Object.assign({}, options), { params: [subId] })));
+            return multicall(web3, this.chainId, multicallCalls);
         });
     }
     getSubscriptionEventsFromSubStorage(options) {

package/esm/services/ethereumService.d.ts

@@ -4,4 +4,4 @@ import type { BlockNumber, Multicall, Contract } from '../types';
 import type { BaseContract } from '../types/contracts/generated/types';
 import type { ChainId } from '../types/enums';
 export declare function multicall(web3: Web3, chainId: ChainId, calls: Multicall.Calls[], block?: BlockNumber): Promise<Multicall.Payload>;
-export declare function getEventsFromContract<T extends BaseContract>(contractWithMeta: Contract.WithMeta<T>, event: string, options?: PastEventOptions): Promise<import("web3-eth-contract").EventData[]>;
+export declare function getEventsFromContract<T extends BaseContract>(contractWithMeta: Contract.WithMeta<T>, contractWithMetaFork: Contract.WithMeta<T> | null, event: string, options?: PastEventOptions): Promise<any[]>;

package/esm/services/ethereumService.js

@@ -29,6 +29,13 @@ export function multicall(web3, chainId, calls, block = 'latest') {
         return formattedResult;
     });
 }
-export function getEventsFromContract(contractWithMeta, event, options) {
-    return contractWithMeta.contract.getPastEvents(event, Object.assign({ fromBlock: contractWithMeta.createdBlock }, addToObjectIf(isDefined(options), options)));
+export function getEventsFromContract(contractWithMeta, contractWithMetaFork, event, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const events = yield contractWithMeta.contract.getPastEvents(event, Object.assign({}, addToObjectIf(isDefined(options), Object.assign(Object.assign({}, options), { fromBlock: contractWithMeta.createdBlock }))));
+        let eventsFork = [];
+        if (contractWithMetaFork) {
+            eventsFork = yield contractWithMetaFork.contract.getPastEvents(event, Object.assign({}, addToObjectIf(isDefined(options), Object.assign(Object.assign({}, options), { toBlock: 'latest' }))));
+        }
+        return [...events, ...eventsFork];
+    });
 }

package/esm/types/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "",
   "main": "./umd/index.js",
   "module": "./esm/index.js",

package/src/automation/private/StrategiesAutomation.ts

@@ -19,6 +19,7 @@ import type { ChainId } from '../../types/enums';
 
 interface IStrategiesAutomation extends Interfaces.Automation {
   chainId: ChainId,
+  providerFork: Web3,
 }
 
 export default class StrategiesAutomation extends Automation {
@@ -26,33 +27,48 @@ export default class StrategiesAutomation extends Automation {
 
   protected web3: Web3;
 
+  protected web3Fork: Web3;
+
   protected subStorageContract: Contract.WithMeta<SubStorage>;
 
+  protected subStorageContractFork: Contract.WithMeta<SubStorage> | null;
+
   constructor(args: IStrategiesAutomation) {
     super();
 
     this.web3 = args.provider;
+    this.web3Fork = args.providerFork;
     this.chainId = args.chainId;
     this.subStorageContract = makeSubStorageContract(this.web3, this.chainId);
+    this.subStorageContractFork = this.web3Fork ? makeSubStorageContract(this.web3Fork, this.chainId) : null;
 
     this.assert();
   }
 
   protected async getEventFromSubStorage(event: string, options?: PastEventOptions) {
-    return getEventsFromContract<SubStorage>(this.subStorageContract, event, options);
+    return getEventsFromContract<SubStorage>(this.subStorageContract, this.subStorageContractFork, event, options);
   }
 
   protected async getStrategiesSubs(subIds: number[]): Promise<StrategyModel.StoredSubDataStructOutputStruct[]> {
-    const subStorageContract = this.subStorageContract;
-
-    const defaultOptions = {
-      target: subStorageContract.address,
-      abiItem: getAbiItem(subStorageContract.abi, 'strategiesSubs'),
-    };
-
-    const multicallCalls = subIds.map((subId) => ({ ...defaultOptions, params: [subId] }));
+    let options : any;
+    let web3: Web3;
+
+    if (this.web3Fork && this.subStorageContractFork) {
+      options = {
+        target: this.subStorageContractFork.address,
+        abiItem: getAbiItem(this.subStorageContractFork.abi, 'strategiesSubs'),
+      };
+      web3 = this.web3Fork;
+    } else {
+      options = {
+        target: this.subStorageContract.address,
+        abiItem: getAbiItem(this.subStorageContract.abi, 'strategiesSubs'),
+      };
+      web3 = this.web3;
+    }
 
-    return multicall(this.web3, this.chainId, multicallCalls);
+    const multicallCalls = subIds.map((subId) => ({ ...options, params: [subId] }));
+    return multicall(web3, this.chainId, multicallCalls);
   }
 
   protected async getSubscriptionEventsFromSubStorage(options?: PastEventOptions) {
@@ -75,6 +91,7 @@ export default class StrategiesAutomation extends Automation {
       ...addToObjectIf(isDefined(addresses), { filter: { proxy: addresses } }),
     };
 
+
     const subscriptionEvents = (await this.getSubscriptionEventsFromSubStorage(_options)) as PlaceholderType; // TODO PlaceholderType
 
     let subscriptions: (Position.Automated | null)[] = [];

package/src/services/ethereumService.ts

@@ -1,7 +1,7 @@
 import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
 import type {
-  BlockNumber, Multicall, Contract,
+  BlockNumber, Multicall, Contract, PlaceholderType,
 } from '../types';
 
 import { makeUniMulticallContract } from './contractService';
@@ -41,15 +41,28 @@ export async function multicall(
   return formattedResult;
 }
 
-export function getEventsFromContract<T extends BaseContract>(
+export async function getEventsFromContract<T extends BaseContract>(
   contractWithMeta: Contract.WithMeta<T>,
+  contractWithMetaFork: Contract.WithMeta<T> | null,
   event: string, options?: PastEventOptions,
 ) {
-  return contractWithMeta.contract.getPastEvents(
+  const events = await contractWithMeta.contract.getPastEvents(
     event,
     {
-      fromBlock: contractWithMeta.createdBlock,
-      ...addToObjectIf(isDefined(options), options),
+      ...addToObjectIf(isDefined(options), { ...options, fromBlock: contractWithMeta.createdBlock }),
     },
   );
+
+  let eventsFork : PlaceholderType = [];
+
+  if (contractWithMetaFork) {
+    eventsFork = await contractWithMetaFork.contract.getPastEvents(
+      event,
+      {
+        ...addToObjectIf(isDefined(options), { ...options, toBlock: 'latest' }),
+      },
+    );
+  }
+
+  return [...events, ...eventsFork];
 }

package/src/types/index.ts

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

package/umd/index.js

@@ -1017,10 +1017,23 @@ function _multicall() {
   });
   return _multicall.apply(this, arguments);
 }
-function getEventsFromContract(contractWithMeta, event, options) {
-  return contractWithMeta.contract.getPastEvents(event, _objectSpread({
-    fromBlock: contractWithMeta.createdBlock
-  }, (0,_utils__WEBPACK_IMPORTED_MODULE_1__.addToObjectIf)((0,_utils__WEBPACK_IMPORTED_MODULE_1__.isDefined)(options), options)));
+function getEventsFromContract(_x4, _x5, _x6, _x7) {
+  return _getEventsFromContract.apply(this, arguments);
+}
+function _getEventsFromContract() {
+  _getEventsFromContract = _asyncToGenerator(function* (contractWithMeta, contractWithMetaFork, event, options) {
+    var events = yield contractWithMeta.contract.getPastEvents(event, _objectSpread({}, (0,_utils__WEBPACK_IMPORTED_MODULE_1__.addToObjectIf)((0,_utils__WEBPACK_IMPORTED_MODULE_1__.isDefined)(options), _objectSpread(_objectSpread({}, options), {}, {
+      fromBlock: contractWithMeta.createdBlock
+    }))));
+    var eventsFork = [];
+    if (contractWithMetaFork) {
+      eventsFork = yield contractWithMetaFork.contract.getPastEvents(event, _objectSpread({}, (0,_utils__WEBPACK_IMPORTED_MODULE_1__.addToObjectIf)((0,_utils__WEBPACK_IMPORTED_MODULE_1__.isDefined)(options), _objectSpread(_objectSpread({}, options), {}, {
+        toBlock: 'latest'
+      }))));
+    }
+    return [...events, ...eventsFork];
+  });
+  return _getEventsFromContract.apply(this, arguments);
 }
 
 /***/ }),
@@ -1191,30 +1204,44 @@ class StrategiesAutomation extends _Automation__WEBPACK_IMPORTED_MODULE_4__["def
     super();
     _defineProperty(this, "chainId", void 0);
     _defineProperty(this, "web3", void 0);
+    _defineProperty(this, "web3Fork", void 0);
     _defineProperty(this, "subStorageContract", void 0);
+    _defineProperty(this, "subStorageContractFork", void 0);
     this.web3 = args.provider;
+    this.web3Fork = args.providerFork;
     this.chainId = args.chainId;
     this.subStorageContract = (0,_services_contractService__WEBPACK_IMPORTED_MODULE_2__.makeSubStorageContract)(this.web3, this.chainId);
+    this.subStorageContractFork = this.web3Fork ? (0,_services_contractService__WEBPACK_IMPORTED_MODULE_2__.makeSubStorageContract)(this.web3Fork, this.chainId) : null;
     this.assert();
   }
   getEventFromSubStorage(event, options) {
     var _this = this;
     return _asyncToGenerator(function* () {
-      return (0,_services_ethereumService__WEBPACK_IMPORTED_MODULE_3__.getEventsFromContract)(_this.subStorageContract, event, options);
+      return (0,_services_ethereumService__WEBPACK_IMPORTED_MODULE_3__.getEventsFromContract)(_this.subStorageContract, _this.subStorageContractFork, event, options);
     })();
   }
   getStrategiesSubs(subIds) {
     var _this2 = this;
     return _asyncToGenerator(function* () {
-      var subStorageContract = _this2.subStorageContract;
-      var defaultOptions = {
-        target: subStorageContract.address,
-        abiItem: (0,_services_contractService__WEBPACK_IMPORTED_MODULE_2__.getAbiItem)(subStorageContract.abi, 'strategiesSubs')
-      };
-      var multicallCalls = subIds.map(subId => _objectSpread(_objectSpread({}, defaultOptions), {}, {
+      var options;
+      var web3;
+      if (_this2.web3Fork && _this2.subStorageContractFork) {
+        options = {
+          target: _this2.subStorageContractFork.address,
+          abiItem: (0,_services_contractService__WEBPACK_IMPORTED_MODULE_2__.getAbiItem)(_this2.subStorageContractFork.abi, 'strategiesSubs')
+        };
+        web3 = _this2.web3Fork;
+      } else {
+        options = {
+          target: _this2.subStorageContract.address,
+          abiItem: (0,_services_contractService__WEBPACK_IMPORTED_MODULE_2__.getAbiItem)(_this2.subStorageContract.abi, 'strategiesSubs')
+        };
+        web3 = _this2.web3;
+      }
+      var multicallCalls = subIds.map(subId => _objectSpread(_objectSpread({}, options), {}, {
         params: [subId]
       }));
-      return (0,_services_ethereumService__WEBPACK_IMPORTED_MODULE_3__.multicall)(_this2.web3, _this2.chainId, multicallCalls);
+      return (0,_services_ethereumService__WEBPACK_IMPORTED_MODULE_3__.multicall)(web3, _this2.chainId, multicallCalls);
     })();
   }
   getSubscriptionEventsFromSubStorage(options) {