@defisaver/automation-sdk 1.2.2 → 1.2.4

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

@@ -2,20 +2,23 @@ import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
 import type { Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData } from '../../types';
 import type { StrategyModel, SubStorage } from '../../types/contracts/generated/SubStorage';
-import Automation from './Automation';
 import type { ChainId } from '../../types/enums';
+import Automation from './Automation';
 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

@@ -11,30 +11,43 @@ import Dec from 'decimal.js';
 import { addToObjectIf, isDefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
 import { getEventsFromContract, multicall } from '../../services/ethereumService';
-import Automation from './Automation';
 import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
+import Automation from './Automation';
 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/constants/index.js

@@ -140,6 +140,16 @@ export const MAINNET_BUNDLES_INFO = {
         strategyId: Strategies.Identifiers.Boost,
         protocol: PROTOCOLS.MakerDAO,
     },
+    [Bundles.MainnetIds.AAVE_V3_CLOSE_TO_DEBT]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_CLOSE_TO_DEBT,
+        strategyId: Strategies.Identifiers.CloseOnPriceToDebt,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.MainnetIds.AAVE_V3_CLOSE_TO_COLLATERAL]: {
+        strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_CLOSE_TO_COLLATERAL,
+        strategyId: Strategies.Identifiers.CloseOnPriceToColl,
+        protocol: PROTOCOLS.AaveV3,
+    },
 };
 export const OPTIMISM_BUNDLES_INFO = {
     [Bundles.OptimismIds.AAVE_V3_REPAY]: {

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/enums.d.ts

@@ -84,7 +84,9 @@ export declare namespace Bundles {
         AAVE_V3_REPAY = 8,
         AAVE_V3_BOOST = 9,
         MAKER_REPAY = 10,
-        MAKER_BOOST = 11
+        MAKER_BOOST = 11,
+        AAVE_V3_CLOSE_TO_DEBT = 12,
+        AAVE_V3_CLOSE_TO_COLLATERAL = 13
     }
     enum OptimismIds {
         AAVE_V3_REPAY = 0,

package/esm/types/enums.js

@@ -99,6 +99,8 @@ export var Bundles;
         MainnetIds[MainnetIds["AAVE_V3_BOOST"] = 9] = "AAVE_V3_BOOST";
         MainnetIds[MainnetIds["MAKER_REPAY"] = 10] = "MAKER_REPAY";
         MainnetIds[MainnetIds["MAKER_BOOST"] = 11] = "MAKER_BOOST";
+        MainnetIds[MainnetIds["AAVE_V3_CLOSE_TO_DEBT"] = 12] = "AAVE_V3_CLOSE_TO_DEBT";
+        MainnetIds[MainnetIds["AAVE_V3_CLOSE_TO_COLLATERAL"] = 13] = "AAVE_V3_CLOSE_TO_COLLATERAL";
     })(MainnetIds = Bundles.MainnetIds || (Bundles.MainnetIds = {}));
     let OptimismIds;
     (function (OptimismIds) {

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;
@@ -121,6 +122,7 @@ export declare namespace Position {
             closeToAssetAddr: EthereumAddress;
         }
     }
+    type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave;
     interface Automated {
         chainId: ChainId;
         owner: EthereumAddress;
@@ -141,7 +143,7 @@ export declare namespace Position {
                 subData: PlaceholderType;
             };
         };
-        specific: Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave;
+        specific: SpecificAny;
     }
     interface LegacyAutomated {
         chainId: ChainId;

package/package.json

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

package/src/automation/private/StrategiesAutomation.ts

@@ -8,17 +8,18 @@ import type {
 import type {
   Subscribe, StrategyModel, SubStorage, UpdateData,
 } from '../../types/contracts/generated/SubStorage';
+import type { ChainId } from '../../types/enums';
 
 import { addToObjectIf, isDefined } from '../../services/utils';
 import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
 import { getEventsFromContract, multicall } from '../../services/ethereumService';
+import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
 
 import Automation from './Automation';
-import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
-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/constants/index.ts

@@ -156,6 +156,16 @@ export const MAINNET_BUNDLES_INFO: MainnetBundleInfo = {
     strategyId: Strategies.Identifiers.Boost,
     protocol: PROTOCOLS.MakerDAO,
   },
+  [Bundles.MainnetIds.AAVE_V3_CLOSE_TO_DEBT]: {
+    strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_CLOSE_TO_DEBT,
+    strategyId: Strategies.Identifiers.CloseOnPriceToDebt,
+    protocol: PROTOCOLS.AaveV3,
+  },
+  [Bundles.MainnetIds.AAVE_V3_CLOSE_TO_COLLATERAL]: {
+    strategyOrBundleId: Bundles.MainnetIds.AAVE_V3_CLOSE_TO_COLLATERAL,
+    strategyId: Strategies.Identifiers.CloseOnPriceToColl,
+    protocol: PROTOCOLS.AaveV3,
+  },
 };
 
 export const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo = {

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/services/strategiesService.ts

@@ -294,7 +294,7 @@ function parseLiquityBondProtection(position: Position.Automated, parseData: Par
 
 const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
   [ProtocolIdentifiers.StrategiesAutomation.MakerDAO]: {
-    [Strategies.Identifiers.SavingsLiqProtection]: parseMakerSavingsLiqProtection, // TODO union type by protocol
+    [Strategies.Identifiers.SavingsLiqProtection]: parseMakerSavingsLiqProtection,
     [Strategies.Identifiers.CloseOnPriceToDebt]: parseMakerCloseOnPrice,
     [Strategies.Identifiers.CloseOnPriceToColl]: parseMakerCloseOnPrice,
     [Strategies.Identifiers.TrailingStopToColl]: parseMakerTrailingStop,

package/src/types/enums.ts

@@ -92,6 +92,8 @@ export namespace Bundles {
     AAVE_V3_BOOST = 9,
     MAKER_REPAY = 10,
     MAKER_BOOST = 11,
+    AAVE_V3_CLOSE_TO_DEBT = 12,
+    AAVE_V3_CLOSE_TO_COLLATERAL = 13,
   }
 
   export enum OptimismIds {

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,
@@ -146,6 +147,8 @@ export declare namespace Position {
     }
   }
 
+  type SpecificAny = Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave;
+
   export interface Automated {
     chainId: ChainId,
     owner: EthereumAddress,
@@ -166,7 +169,7 @@ export declare namespace Position {
         subData: PlaceholderType,
       },
     },
-    specific: Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave,
+    specific: SpecificAny,
   }
 
   export interface LegacyAutomated {