@defisaver/automation-sdk 2.0.2 → 2.0.3

package/esm/services/utils.test.js

@@ -0,0 +1,362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const web3Utils = __importStar(require("web3-utils"));
+const web3_eth_abi_1 = __importDefault(require("web3-eth-abi"));
+const tokens_1 = require("@defisaver/tokens");
+const enums_1 = require("../types/enums");
+const strategySubService_1 = require("./strategySubService");
+const utils_1 = require("./utils");
+describe('Feature: utils.ts', () => {
+    describe('When testing utils.isDefined()', () => {
+        const examples = [
+            [true, 'something'],
+            [true, NaN],
+            [true, 0],
+            [false, undefined],
+            [false, null],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isDefined)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.isUndefined()', () => {
+        const examples = [
+            [false, 'something'],
+            [false, NaN],
+            [false, 0],
+            [true, undefined],
+            [true, null],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isUndefined)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.compareAddresses()', () => {
+        const examples = [
+            [true, ['nesto', 'nesto']],
+            [true, ['', '']],
+            [false, ['something', 'nesto']],
+            [false, ['', 'nesto']],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.compareAddresses)(...actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.isAddress()', () => {
+        const examples = [
+            [true, '0x996bc83fa1b947cca00e5dcf776c438096549062'],
+            [true, '0x0000000000000000000000000000000000000000'],
+            [false, '0x996bc83fa147cca00e5dcf776c438096549062'],
+            [false, '0x996bc83fa147cca00e5dcf776c438096549062xx'],
+            [false, ''],
+            [false, 'majmune.eth'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isAddress)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.addToArrayIf()', () => {
+        const exampleOne = [1, ...(0, utils_1.addToArrayIf)(true, 2)];
+        const actualOne = [1, 2];
+        it(`Given ${actualOne.join(', ')} should return expected value: [${exampleOne.join(', ')}]`, () => {
+            (0, chai_1.expect)(actualOne).to.eql(exampleOne);
+        });
+        const exampleTwo = [1, ...(0, utils_1.addToArrayIf)(false, 2)];
+        const actualTwo = [1];
+        it(`Given ${actualTwo.join(', ')} should return expected value: [${exampleTwo.join(', ')}]`, () => {
+            (0, chai_1.expect)(actualTwo).to.eql(exampleTwo);
+        });
+    });
+    describe('When testing utils.addToObjectIf()', () => {
+        const exampleOne = Object.assign({ a: 1 }, (0, utils_1.addToObjectIf)(true, { b: 2 }));
+        const actualOne = { a: 1, b: 2 };
+        it(`Given ${JSON.stringify(actualOne)} should return expected value: ${JSON.stringify(exampleOne)}`, () => {
+            (0, chai_1.expect)(actualOne).to.eql(exampleOne);
+        });
+        const exampleTwo = Object.assign({ a: 1 }, (0, utils_1.addToObjectIf)(false, { b: 2 }));
+        const actualTwo = { a: 1 };
+        it(`Given ${JSON.stringify(actualTwo)} should return expected value: ${JSON.stringify(exampleTwo)}`, () => {
+            (0, chai_1.expect)(actualTwo).to.eql(exampleTwo);
+        });
+    });
+    describe('When testing utils.ethToWeth()', () => {
+        const examples = [
+            ['WETH', 'ETH'],
+            ['rETH', 'rETH'],
+            ['ETH.c', 'ETH.c'],
+            ['cETHx2', 'cETHx2'],
+            ['WETH', 'WETH'],
+            ['DAI', 'DAI'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.ethToWeth)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.wethToEth()', () => {
+        const examples = [
+            ['ETH', 'ETH'],
+            ['rETH', 'rETH'],
+            ['ETH.c', 'ETH.c'],
+            ['cETHx2', 'cETHx2'],
+            ['ETH', 'WETH'],
+            ['DAI', 'DAI'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.wethToEth)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.wethToEthByAddress()', () => {
+        /**
+         * @dev wethToEthByAddress will return empty string when asset doesn't exist in assets array of @defisaver/tokens
+         *      This is @defisaver/tokens problem, but still seems like a wierd behaviour
+         */
+        const examples = [
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', 1]],
+            ['0xb3319f5d18bc0d84dd1b4825dcde5d5f7266d407', ['0xb3319f5d18bc0d84dd1b4825dcde5d5f7266d407', 1]],
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 1]],
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0x4200000000000000000000000000000000000006', 10]],
+            ['0xab7badef82e9fe11f6f33f87bc9bc2aa27f2fcb5', ['0xab7badef82e9fe11f6f33f87bc9bc2aa27f2fcb5', 10]],
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 10]],
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', 42161]],
+            ['0xaf88d065e77c8cC2239327C5EDb3A432268e5831', ['0xaf88d065e77c8cC2239327C5EDb3A432268e5831', 42161]],
+            ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 42161]],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.wethToEthByAddress)(...actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.compareSubHashes()', () => {
+        const subDataToEncodeOne = [
+            12,
+            false,
+            {
+                baseTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                quoteTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                price: 100,
+                ratioState: 1,
+            },
+            {
+                collAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                collAssetId: 2,
+                debtAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                debtAssetId: 3,
+            },
+        ];
+        const subDataToEncodeTwo = [
+            13,
+            true,
+            {
+                baseTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                quoteTokenAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                price: 100,
+                ratioState: 2,
+            },
+            {
+                collAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                collAssetId: 2,
+                debtAsset: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+                debtAssetId: 3,
+            },
+        ];
+        // @ts-ignore
+        const encodedSubDataOne = strategySubService_1.sparkEncode.closeToAsset(...subDataToEncodeOne);
+        // @ts-ignore
+        const encodedSubDataTwo = strategySubService_1.sparkEncode.closeToAsset(...subDataToEncodeTwo);
+        const encodedParams = web3Utils.keccak256(web3_eth_abi_1.default.encodeParameter('(uint64,bool,bytes[],bytes32[])', encodedSubDataOne));
+        const examples = [
+            [true, [encodedParams, encodedSubDataOne]],
+            [false, [encodedParams, encodedSubDataTwo]],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.compareSubHashes)(...actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.encodeSubId()', () => {
+        const examples = [
+            ['00000001', '1'],
+            ['00000002', '2'],
+            ['0021c503', '2213123']
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.encodeSubId)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.ratioPercentageToWei()', () => {
+        const examples = [
+            ['1200000000000000000', 120],
+            ['2400000000000000000', 240],
+            ['870000000000000000', 87],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.ratioPercentageToWei)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.weiToRatioPercentage()', () => {
+        const examples = [
+            [120, '1200000000000000000'],
+            [240, '2400000000000000000'],
+            [87, '870000000000000000'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.weiToRatioPercentage)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.isRatioStateOver()', () => {
+        const examples = [
+            [true, enums_1.RatioState.OVER],
+            [false, enums_1.RatioState.UNDER],
+            [false, NaN],
+            [false, 3],
+            [false, Infinity],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isRatioStateOver)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.isRatioStateUnder()', () => {
+        const examples = [
+            [true, enums_1.RatioState.UNDER],
+            [false, enums_1.RatioState.OVER],
+            [false, NaN],
+            [false, 3],
+            [false, Infinity],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isRatioStateUnder)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.isEmptyBytes()', () => {
+        const examples = [
+            [true, '0x0000000000000000000000000000000000000000'],
+            [false, '0x0000000000000000000000000000000000000001'],
+            [false, '0x00000000000000000000000000000000000000000000'],
+            [false, '0x000000000000000000000000000000000000000'],
+            [false, ''],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${expected}`, () => {
+                (0, chai_1.expect)((0, utils_1.isEmptyBytes)(actual)).to.equal(expected);
+            });
+        });
+    });
+    describe('When testing utils.requireAddress()', () => {
+        const examples = [
+            [true, '0x1e5698681E03326d783215adfB3173acF3Cf2B6'],
+            [true, 1312],
+            [true, ''],
+            [true, '0x0000000000000000000000000000000000000000'],
+            [true, '0xZe5698681E03326d783215adfB3173acF3Cf2B6'],
+            [true, 'Ze5698681E03326d783215adfB3173acF3Cf2B6'],
+            [false, '0x1e5698681E03326d783215adfB3173acF3Cf2B61'],
+        ];
+        examples.forEach(([expected, actual]) => {
+            if (expected) {
+                it(`Given ${actual} should throw an error`, () => {
+                    (0, chai_1.expect)(() => (0, utils_1.requireAddress)(actual)).to.throw(Error);
+                });
+            }
+            else {
+                it(`Given ${actual} should not throw an error`, () => {
+                    (0, chai_1.expect)(() => (0, utils_1.requireAddress)(actual)).not.to.throw(Error);
+                });
+            }
+        });
+    });
+    describe('When testing utils.requireAddresses()', () => {
+        const examples = [
+            [true, '0x1e5698681E03326d783215adfB3173acF3Cf2B6'],
+            [true, [1312, '0x1e5698681E03326d783215adfB3173acF3Cf2B61']],
+            [true, ['', '0x1e5698681E03326d783215adfB3173acF3Cf2B61']],
+            [true, ['0x0000000000000000000000000000000000000000', '0x1e5698481E03326d783215adfB3173acF3Cf2B61']],
+            [true, ['0xZe5698681E03326d783215adfB3173acF3Cf2B6', '0x1e5698681E03326d783215adfB3173acF3Cc2B61']],
+            [true, ['Ze5698681E03326d783215adfB3173acF3Cf2B6', '', '0x1e5698681E03326d783215adfB3173acF3Cf2B61']],
+            [false, ['0x1e5698681E03326d783215adfB3173acF3Cf2B61', '0x2e5698681E03326d783215adfB3173acF3Cf2B61']],
+        ];
+        examples.forEach(([expected, actual]) => {
+            if (expected) {
+                it(`Given ${actual} should throw an error`, () => {
+                    (0, chai_1.expect)(() => (0, utils_1.requireAddresses)(actual)).to.throw(Error);
+                });
+            }
+            else {
+                it(`Given ${actual} should not throw an error`, () => {
+                    (0, chai_1.expect)(() => (0, utils_1.requireAddresses)(actual)).not.to.throw(Error);
+                });
+            }
+        });
+    });
+    describe('When testing utils.getRatioStateInfoForAaveCloseStrategy()', () => {
+        const examples = [
+            [
+                { shouldFlip: true, ratioState: enums_1.RatioState.UNDER },
+                [enums_1.RatioState.OVER, (0, tokens_1.getAssetInfo)('DAI').address, (0, tokens_1.getAssetInfo)('ETH').address, enums_1.ChainId.Ethereum]
+            ],
+            [
+                { shouldFlip: false, ratioState: enums_1.RatioState.UNDER },
+                [enums_1.RatioState.UNDER, (0, tokens_1.getAssetInfo)('DAI').address, (0, tokens_1.getAssetInfo)('ETH').address, enums_1.ChainId.Arbitrum]
+            ],
+            [
+                { shouldFlip: false, ratioState: enums_1.RatioState.OVER },
+                [enums_1.RatioState.OVER, (0, tokens_1.getAssetInfo)('ETH').address, (0, tokens_1.getAssetInfo)('ETH').address, enums_1.ChainId.Optimism]
+            ],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
+                (0, chai_1.expect)((0, utils_1.getRatioStateInfoForAaveCloseStrategy)(...actual)).to.eql(expected);
+            });
+        });
+    });
+});

package/esm/types/contracts/generated/Erc20.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/Legacy_AaveV2Subscriptions.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/Legacy_AuthCheck.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/Legacy_CompoundV2Subscriptions.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/Legacy_MakerSubscriptions.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/SubStorage.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/UniMulticall.js

@@ -1,4 +1,5 @@
+"use strict";
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/index.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/contracts/generated/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/types/enums.js

@@ -1,25 +1,28 @@
-export var ChainId;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundles = exports.Strategies = exports.ProtocolIdentifiers = exports.BundleProtocols = exports.OrderType = exports.RatioState = exports.ChainId = void 0;
+var ChainId;
 (function (ChainId) {
     ChainId[ChainId["Ethereum"] = 1] = "Ethereum";
     ChainId[ChainId["Optimism"] = 10] = "Optimism";
     ChainId[ChainId["Arbitrum"] = 42161] = "Arbitrum";
-})(ChainId || (ChainId = {}));
-export var RatioState;
+})(ChainId = exports.ChainId || (exports.ChainId = {}));
+var RatioState;
 (function (RatioState) {
     RatioState[RatioState["OVER"] = 0] = "OVER";
     RatioState[RatioState["UNDER"] = 1] = "UNDER";
-})(RatioState || (RatioState = {}));
-export var OrderType;
+})(RatioState = exports.RatioState || (exports.RatioState = {}));
+var OrderType;
 (function (OrderType) {
     OrderType[OrderType["TAKE_PROFIT"] = 0] = "TAKE_PROFIT";
     OrderType[OrderType["STOP_LOSS"] = 1] = "STOP_LOSS";
-})(OrderType || (OrderType = {}));
-export var BundleProtocols;
+})(OrderType = exports.OrderType || (exports.OrderType = {}));
+var BundleProtocols;
 (function (BundleProtocols) {
     BundleProtocols["MStable"] = "mstable";
     BundleProtocols["Yearn"] = "yearn";
     BundleProtocols["Rari"] = "rari";
-})(BundleProtocols || (BundleProtocols = {}));
+})(BundleProtocols = exports.BundleProtocols || (exports.BundleProtocols = {}));
 /**
  * @dev Follow the naming convention:
  *      - Enum name consists of two parts, name and version
@@ -27,7 +30,7 @@ export var BundleProtocols;
  *      - Version should be separated from the name with double underscores `__` (If there is no version leave it out)
  *      - Example `Name of ThePROTOCOL__v1` (Without version `Name of ThePROTOCOL`)
  */
-export var ProtocolIdentifiers;
+var ProtocolIdentifiers;
 (function (ProtocolIdentifiers) {
     let StrategiesAutomation;
     (function (StrategiesAutomation) {
@@ -48,8 +51,8 @@ export var ProtocolIdentifiers;
         LegacyAutomation["CompoundV2"] = "Compound__V2";
         LegacyAutomation["AaveV2"] = "Aave__V2";
     })(LegacyAutomation = ProtocolIdentifiers.LegacyAutomation || (ProtocolIdentifiers.LegacyAutomation = {}));
-})(ProtocolIdentifiers || (ProtocolIdentifiers = {}));
-export var Strategies;
+})(ProtocolIdentifiers = exports.ProtocolIdentifiers || (exports.ProtocolIdentifiers = {}));
+var Strategies;
 (function (Strategies) {
     let MainnetIds;
     (function (MainnetIds) {
@@ -104,8 +107,8 @@ export var Strategies;
         IdOverrides["LeverageManagement"] = "leverage-management";
         IdOverrides["EoaLeverageManagement"] = "leverage-management-eoa";
     })(IdOverrides = Strategies.IdOverrides || (Strategies.IdOverrides = {}));
-})(Strategies || (Strategies = {}));
-export var Bundles;
+})(Strategies = exports.Strategies || (exports.Strategies = {}));
+var Bundles;
 (function (Bundles) {
     let MainnetIds;
     (function (MainnetIds) {
@@ -150,4 +153,4 @@ export var Bundles;
         ArbitrumIds[ArbitrumIds["AAVE_V3_CLOSE_TO_DEBT"] = 2] = "AAVE_V3_CLOSE_TO_DEBT";
         ArbitrumIds[ArbitrumIds["AAVE_V3_CLOSE_TO_COLLATERAL"] = 3] = "AAVE_V3_CLOSE_TO_COLLATERAL";
     })(ArbitrumIds = Bundles.ArbitrumIds || (Bundles.ArbitrumIds = {}));
-})(Bundles || (Bundles = {}));
+})(Bundles = exports.Bundles || (exports.Bundles = {}));

package/esm/types/index.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/automation-sdk",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "",
   "main": "./umd/index.js",
   "module": "./esm/index.js",
@@ -14,7 +14,8 @@
     "document": "npx typedoc --out docs/default",
     "lint": "node_modules/.bin/eslint ./src",
     "gtc": "node scripts/generateContractTypes.js",
-    "prepare": "husky install && npm run gtc"
+    "prepare": "husky install && npm run gtc",
+    "test": "mocha \"./src/**/*.test.ts\" --loader=ts-node/esm --extension ts"
   },
   "author": "DeFi Saver",
   "repository": "https://github.com/defisaver/automation-sdk",
@@ -27,7 +28,8 @@
     "@ethersproject/solidity": "^5.0.9",
     "decimal.js": "^10.4.3",
     "lodash": "^4.17.21",
-    "web3": "^1.10.1"
+    "web3-eth-abi": "^1.10.2",
+    "web3-utils": "^1.10.2"
   },
   "devDependencies": {
     "@babel/core": "^7.12.10",
@@ -35,13 +37,14 @@
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-typescript": "^7.12.7",
     "@typechain/web3-v1": "https://gitpkg.now.sh/mihai9-lab/TypeChain/packages/target-web3-v1?temp",
+    "@types/chai": "^4.3.6",
     "@types/lodash": "^4.14.191",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.11.15",
-    "@types/web3": "^1.2.2",
     "@typescript-eslint/eslint-plugin": "^5.42.0",
     "@typescript-eslint/parser": "^5.42.0",
     "babel-loader": "^8.2.2",
-    "chai": "^4.2.0",
+    "chai": "^4.3.8",
     "dotenv": "^10.0.0",
     "eslint": "8.22.0",
     "eslint-config-airbnb": "^18.0.2",
@@ -52,15 +55,16 @@
     "eslint-plugin-react": "^7.31.11",
     "husky": "^8.0.0",
     "jsdoc-to-markdown": "^6.0.1",
+    "mocha": "^10.2.0",
     "react": "^18.2.0",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.0",
     "typedoc": "^0.23.20",
     "typedoc-plugin-markdown": "^3.13.6",
     "typescript": "^4.8.4",
-    "web3-eth-abi": "^1.8.0",
+    "web3": "^1.10.2",
     "web3-eth-contract": "^1.8.1",
-    "web3-utils": "^1.8.0",
+    "web3-types": "^1.1.1",
     "webpack": "^5.76.0",
     "webpack-cli": "^4.10.0"
   }

package/src/automation/private/LegacyAutomation.ts

@@ -1,6 +1,6 @@
 import type Web3 from 'web3';
 import type {
-  EthereumAddress, Position, Interfaces, Contract, PlaceholderType,
+  EthereumAddress, Position, Interfaces, Contract, PlaceholderType, SubscriptionOptions,
 } from '../../types';
 import type {
   Legacy_AaveV2Subscriptions, Legacy_CompoundV2Subscriptions, Legacy_MakerSubscriptions, Legacy_AuthCheck,
@@ -85,8 +85,8 @@ export default class LegacyAutomation extends Automation {
     return this.protocol.id === ProtocolIdentifiers.LegacyAutomation.MakerDAO ? 'owner' : 'user';
   }
 
-  protected async _getSubscriptions(addresses?: EthereumAddress[]): Promise<PlaceholderType> { // TODO PlaceholderType
-    let subscriptions = await this.subscriptionsContract.contract.methods.getSubscribers().call();
+  protected async _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<PlaceholderType> { // TODO PlaceholderType
+    let subscriptions = await this.subscriptionsContract.contract.methods.getSubscribers().call({}, options?.fromBlock || 'latest');
 
     if (addresses) {
       const _addresses = addresses.map(a => a.toLowerCase());
@@ -98,14 +98,15 @@ export default class LegacyAutomation extends Automation {
     return subscriptions;
   }
 
-  protected async getParsedSubscriptions(addresses?: EthereumAddress[]): Promise<Position.LegacyAutomated[]> {
-    const subscriptions = await this._getSubscriptions(addresses);
+  protected async getParsedSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<Position.LegacyAutomated[]> {
+    const subscriptions = await this._getSubscriptions(addresses, options);
 
     // @ts-ignore
     return subscriptions.map((sub) => ({
       chainId: this.chainId,
       owner: sub[this.getOwnerPropName()],
-      isEnabled: true,
+      isEnabled: (options?.fromBlock && options?.fromBlock !== 'latest')
+        ? options?.fromBlock > 18213086 : false, // Legacy automation was disabled on block 18213086
       protocol: this.protocol,
       specific: { ...sub },
       strategy: {
@@ -115,11 +116,11 @@ export default class LegacyAutomation extends Automation {
     }));
   }
 
-  public async getSubscriptions(): Promise<Position.LegacyAutomated[]> {
-    return this.getParsedSubscriptions();
+  public async getSubscriptions(options?: SubscriptionOptions): Promise<Position.LegacyAutomated[]> {
+    return this.getParsedSubscriptions(undefined, options);
   }
 
-  public async getSubscriptionsFor(addresses: EthereumAddress[]): Promise<Position.LegacyAutomated[]> {
-    return this.getParsedSubscriptions(addresses);
+  public async getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<Position.LegacyAutomated[]> {
+    return this.getParsedSubscriptions(addresses, options);
   }
 }

package/src/automation/private/StrategiesAutomation.ts

@@ -2,11 +2,10 @@ import Dec from 'decimal.js';
 import type Web3 from 'web3';
 import type { PastEventOptions } from 'web3-eth-contract';
 import type {
-  Position, Interfaces, EthereumAddress,
-  SubscriptionOptions, Contract, ParseData, PlaceholderType,
+  Position, Interfaces, EthereumAddress, SubscriptionOptions, Contract, ParseData, PlaceholderType, BlockNumber,
 } from '../../types';
 import type {
-  Subscribe, StrategyModel, SubStorage, UpdateData,
+  StrategyModel, SubStorage,
 } from '../../types/contracts/generated/SubStorage';
 import type { ChainId } from '../../types/enums';
 
@@ -49,7 +48,7 @@ export default class StrategiesAutomation extends Automation {
     return getEventsFromContract<SubStorage>(this.subStorageContract, this.subStorageContractFork, event, options);
   }
 
-  protected async getStrategiesSubs(subIds: number[]): Promise<StrategyModel.StoredSubDataStructOutputStruct[]> {
+  protected async getStrategiesSubs(subIds: number[], fromBlock: BlockNumber = 'latest'): Promise<StrategyModel.StoredSubDataStructOutputStruct[]> {
     let options : any;
     let web3: Web3;
 
@@ -68,7 +67,7 @@ export default class StrategiesAutomation extends Automation {
     }
 
     const multicallCalls = subIds.map((subId) => ({ ...options, params: [subId] }));
-    return multicall(web3, this.chainId, multicallCalls);
+    return multicall(web3, this.chainId, multicallCalls, fromBlock);
   }
 
   protected async getSubscriptionEventsFromSubStorage(options?: PastEventOptions) {
@@ -98,7 +97,7 @@ export default class StrategiesAutomation extends Automation {
 
     if (subscriptionEvents) {
       // @ts-ignore
-      const strategiesSubs = await this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId));
+      const strategiesSubs = await this.getStrategiesSubs(subscriptionEvents.map((e) => e.returnValues.subId), _options.fromBlock);
 
       subscriptions = await Promise.all(strategiesSubs.map(async (sub, index: number) => {
         let latestUpdate = subscriptionEvents[index].returnValues;