@defisaver/automation-sdk 3.0.9-dev → 3.1.1

package/cjs/services/utils.d.ts

@@ -0,0 +1,25 @@
+import type { EthereumAddress } from '../types';
+import { ChainId, RatioState } from '../types/enums';
+export declare function isDefined<T>(value: T): value is NonNullable<T>;
+export declare function isUndefined(value: unknown): boolean;
+export declare function compareAddresses(firstAddress: EthereumAddress, secondAddress: EthereumAddress): boolean;
+export declare function isAddress(address: EthereumAddress): boolean;
+export declare function addToArrayIf(condition: boolean, ...items: any): Array<any>;
+export declare function addToObjectIf(condition: boolean, item: any): object;
+export declare function ethToWeth(maybeEth: string): string;
+export declare function wethToEth(maybeWeth: string): string;
+export declare function wethToEthByAddress(maybeWethAddr: EthereumAddress, chainId?: ChainId): EthereumAddress;
+export declare function compareSubHashes(currentSubHash: string, newSubStructDecoded: object): boolean;
+export declare function encodeSubId(subIdDec?: string): string;
+export declare function ratioPercentageToWei(ratioPercentage: number): string;
+export declare function weiToRatioPercentage(ratioWei: string): number;
+export declare function isRatioStateOver(ratioState: RatioState): boolean;
+export declare function isRatioStateUnder(ratioState: RatioState): boolean;
+export declare function isEmptyBytes(string: string): boolean;
+export declare function requireAddress(address: EthereumAddress): void | never;
+export declare function requireAddresses(addresses: EthereumAddress[]): void;
+export declare function getRatioStateInfoForAaveCloseStrategy(currentRatioState: RatioState, collAsset: EthereumAddress, debtAsset: EthereumAddress, chainId: ChainId): {
+    shouldFlip: boolean;
+    ratioState: RatioState;
+};
+export declare function getPositionId(...args: (number | string)[]): string;

package/cjs/services/utils.js

@@ -0,0 +1,131 @@
+"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 });
+exports.getPositionId = exports.getRatioStateInfoForAaveCloseStrategy = exports.requireAddresses = exports.requireAddress = exports.isEmptyBytes = exports.isRatioStateUnder = exports.isRatioStateOver = exports.weiToRatioPercentage = exports.ratioPercentageToWei = exports.encodeSubId = exports.compareSubHashes = exports.wethToEthByAddress = exports.wethToEth = exports.ethToWeth = exports.addToObjectIf = exports.addToArrayIf = exports.isAddress = exports.compareAddresses = exports.isUndefined = exports.isDefined = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+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");
+function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+exports.isDefined = isDefined;
+function isUndefined(value) {
+    return !isDefined(value);
+}
+exports.isUndefined = isUndefined;
+function compareAddresses(firstAddress, secondAddress) {
+    return firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}
+exports.compareAddresses = compareAddresses;
+function isAddress(address) {
+    return new RegExp(/0x[0-9a-fA-F]{40}/).test(address);
+}
+exports.isAddress = isAddress;
+function addToArrayIf(condition, ...items) {
+    return (condition ? items : []);
+}
+exports.addToArrayIf = addToArrayIf;
+function addToObjectIf(condition, item) {
+    return (condition ? item : {});
+}
+exports.addToObjectIf = addToObjectIf;
+function ethToWeth(maybeEth) {
+    return maybeEth === null || maybeEth === void 0 ? void 0 : maybeEth.replace(/^ETH$/, 'WETH');
+}
+exports.ethToWeth = ethToWeth;
+function wethToEth(maybeWeth) {
+    return maybeWeth === null || maybeWeth === void 0 ? void 0 : maybeWeth.replace(/^WETH$/, 'ETH');
+}
+exports.wethToEth = wethToEth;
+function wethToEthByAddress(maybeWethAddr, chainId = enums_1.ChainId.Ethereum) {
+    return (0, tokens_1.getAssetInfo)(wethToEth((0, tokens_1.getAssetInfoByAddress)(maybeWethAddr, chainId).symbol), chainId).address;
+}
+exports.wethToEthByAddress = wethToEthByAddress;
+function compareSubHashes(currentSubHash, newSubStructDecoded) {
+    return currentSubHash === web3Utils.keccak256(web3_eth_abi_1.default.encodeParameter('(uint64,bool,bytes[],bytes32[])', newSubStructDecoded));
+}
+exports.compareSubHashes = compareSubHashes;
+function encodeSubId(subIdDec = '0') {
+    return new decimal_js_1.default(subIdDec).toHex().slice(2).padStart(8, '0');
+}
+exports.encodeSubId = encodeSubId;
+function ratioPercentageToWei(ratioPercentage) {
+    return web3Utils.toWei(new decimal_js_1.default(ratioPercentage).div(100).toString(), 'ether');
+}
+exports.ratioPercentageToWei = ratioPercentageToWei;
+function weiToRatioPercentage(ratioWei) {
+    return new decimal_js_1.default(web3Utils.fromWei(new decimal_js_1.default(ratioWei).mul(100).toString(), 'ether')).toNumber();
+}
+exports.weiToRatioPercentage = weiToRatioPercentage;
+function isRatioStateOver(ratioState) {
+    return ratioState === enums_1.RatioState.OVER;
+}
+exports.isRatioStateOver = isRatioStateOver;
+function isRatioStateUnder(ratioState) {
+    return ratioState === enums_1.RatioState.UNDER;
+}
+exports.isRatioStateUnder = isRatioStateUnder;
+function isEmptyBytes(string) {
+    return string === '0x0000000000000000000000000000000000000000';
+}
+exports.isEmptyBytes = isEmptyBytes;
+function requireAddress(address) {
+    if (typeof address !== 'string')
+        throw new Error('Address is not a string');
+    if (address === '')
+        throw new Error('Address is empty string');
+    if (address.length < 42)
+        throw new Error(`Address too short (${address.length} instead of 42)`);
+    if (isEmptyBytes(address))
+        throw new Error('Address is empty bytes');
+    if (!(new RegExp(/0x[0-9a-fA-F]{40}/).test(address)))
+        throw new Error('Address invalid');
+}
+exports.requireAddress = requireAddress;
+function requireAddresses(addresses) {
+    addresses.forEach((address) => requireAddress(address));
+}
+exports.requireAddresses = requireAddresses;
+function getRatioStateInfoForAaveCloseStrategy(currentRatioState, collAsset, debtAsset, chainId) {
+    // Flip only if stable/volatile to keep human-readable trigger price setting
+    const shouldFlip = (0, tokens_1.getAssetInfoByAddress)(collAsset, chainId).isStable && !(0, tokens_1.getAssetInfoByAddress)(debtAsset, chainId).isStable;
+    let ratioState = currentRatioState;
+    if (shouldFlip) {
+        ratioState = isRatioStateOver(currentRatioState)
+            ? ratioState = enums_1.RatioState.UNDER
+            : ratioState = enums_1.RatioState.OVER;
+    }
+    return { shouldFlip, ratioState };
+}
+exports.getRatioStateInfoForAaveCloseStrategy = getRatioStateInfoForAaveCloseStrategy;
+function getPositionId(...args) {
+    return args.map(arg => arg.toString().toLowerCase().split(' ').join('_')).join('-');
+}
+exports.getPositionId = getPositionId;

package/cjs/services/utils.test.d.ts

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

package/cjs/services/utils.test.js

@@ -0,0 +1,376 @@
+"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");
+require("../configuration");
+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);
+            });
+        });
+    });
+    describe('When testing utils.getPositionId()', () => {
+        const examples = [
+            [
+                '1-aave__v3-0x9cb7e19861665366011899d74e75d4f2a419aeed-0x2f39d218133afab8f2b819b1066c7e434ad94e9e',
+                [1, enums_1.ProtocolIdentifiers.StrategiesAutomation.AaveV3, '0x9cB7E19861665366011899d74E75d4F2A419aEeD', '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e']
+            ],
+        ];
+        examples.forEach(([expected, actual]) => {
+            it(`Given ${actual} should return expected value: ${JSON.stringify(expected)}`, () => {
+                (0, chai_1.expect)((0, utils_1.getPositionId)(...actual)).to.eql(expected);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export type Approval = ContractEventLog<{
+    owner: string;
+    spender: string;
+    value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export type Transfer = ContractEventLog<{
+    from: string;
+    to: string;
+    value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export interface Erc20 extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): Erc20;
+    clone(): Erc20;
+    methods: {
+        name(): NonPayableTransactionObject<string>;
+        approve(_spender: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        totalSupply(): NonPayableTransactionObject<string>;
+        transferFrom(_from: string, _to: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        decimals(): NonPayableTransactionObject<string>;
+        balanceOf(_owner: string): NonPayableTransactionObject<string>;
+        symbol(): NonPayableTransactionObject<string>;
+        transfer(_to: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        allowance(_owner: string, _spender: string): NonPayableTransactionObject<string>;
+    };
+    events: {
+        Approval(cb?: Callback<Approval>): EventEmitter;
+        Approval(options?: EventOptions, cb?: Callback<Approval>): EventEmitter;
+        Transfer(cb?: Callback<Transfer>): EventEmitter;
+        Transfer(options?: EventOptions, cb?: Callback<Transfer>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "Approval", cb: Callback<Approval>): void;
+    once(event: "Approval", options: EventOptions, cb: Callback<Approval>): void;
+    once(event: "Transfer", cb: Callback<Transfer>): void;
+    once(event: "Transfer", options: EventOptions, cb: Callback<Transfer>): void;
+}

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

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