@defisaver/automation-sdk 1.0.1

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

@@ -0,0 +1,25 @@
+import type Web3 from 'web3';
+import type { EthereumAddress, Position, Interfaces, Contract, PlaceholderType } from '../../types';
+import type { Legacy_AaveV2Subscriptions, Legacy_CompoundV2Subscriptions, Legacy_MakerSubscriptions, Legacy_AuthCheck } from '../../types/contracts/generated';
+import Automation from './Automation';
+import { ChainId } from '../../types/enums';
+export default class LegacyAutomation extends Automation {
+    protected chainId: ChainId;
+    protected web3: Web3;
+    protected monitorAddress: EthereumAddress;
+    protected subscriptionsContract: Contract.WithMeta<Legacy_MakerSubscriptions | Legacy_AaveV2Subscriptions | Legacy_CompoundV2Subscriptions>;
+    protected authCheckerContract: Contract.WithMeta<Legacy_AuthCheck>;
+    protected protocol: Interfaces.LegacyProtocol;
+    constructor(args: Interfaces.LegacyAutomation<Legacy_MakerSubscriptions | Legacy_AaveV2Subscriptions | Legacy_CompoundV2Subscriptions>);
+    protected assertSubscriptionContract(): void;
+    protected assertProtocol(): void;
+    protected assertMonitorAddress(): void;
+    protected assertLegacy(): void;
+    protected isMonitorAuthorized(address: EthereumAddress, caller: EthereumAddress): Promise<boolean>;
+    protected isMonitorAuthorizedMulticall(addresses: EthereumAddress[], caller: EthereumAddress): Promise<boolean[]>;
+    private getOwnerPropName;
+    protected _getSubscriptions(addresses?: EthereumAddress[]): Promise<PlaceholderType>;
+    protected getParsedSubscriptions(addresses?: EthereumAddress[]): Promise<Position.LegacyAutomated[]>;
+    getSubscriptions(): Promise<Position.LegacyAutomated[]>;
+    getSubscriptionsFor(addresses: EthereumAddress[]): Promise<Position.LegacyAutomated[]>;
+}

package/esm/automation/private/LegacyAutomation.js

@@ -0,0 +1,102 @@
+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 { getAbiItem, makeAuthCheckerContract } from '../../services/contractService';
+import { multicall } from '../../services/ethereumService';
+import { isAddress, isUndefined } from '../../services/utils';
+import Automation from './Automation';
+import { ChainId, ProtocolIdentifiers } from '../../types/enums';
+export default class LegacyAutomation extends Automation {
+    constructor(args) {
+        super();
+        this.chainId = ChainId.Ethereum;
+        this.web3 = args.provider;
+        this.subscriptionsContract = args.subscriptionsJson;
+        this.monitorAddress = args.monitorAddress;
+        this.protocol = args.protocol;
+        this.authCheckerContract = makeAuthCheckerContract(this.web3, this.chainId);
+        this.assertLegacy();
+    }
+    assertSubscriptionContract() {
+        if (isUndefined(this.subscriptionsContract)) {
+            throw new Error(`Assertion for property 'subscriptionsContract' failed. \nGot: '${this.subscriptionsContract}.`);
+        }
+    }
+    assertProtocol() {
+        if (isUndefined(this.protocol)) {
+            throw new Error(`Assertion for property 'protocol' failed. \nGot: '${this.protocol}.`);
+        }
+    }
+    assertMonitorAddress() {
+        if (!isAddress(this.monitorAddress)) {
+            throw new Error(`Assertion for property 'monitorAddress' failed. \nGot: '${this.monitorAddress}.`);
+        }
+    }
+    assertLegacy() {
+        this.assertProtocol();
+        this.assertMonitorAddress();
+        this.assertSubscriptionContract();
+        this.assert();
+    }
+    isMonitorAuthorized(address, caller) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.authCheckerContract.contract.methods.canCall(caller, address, '0x1cff79cd').call();
+        });
+    }
+    isMonitorAuthorizedMulticall(addresses, caller) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authCheckerContract = this.authCheckerContract;
+            const defaultOptions = {
+                target: authCheckerContract.address,
+                abiItem: getAbiItem(authCheckerContract.abi, 'canCall'),
+            };
+            const multicallCalls = addresses.map((addr) => (Object.assign(Object.assign({}, defaultOptions), { params: [caller, addr, '0x1cff79cd'] })));
+            return (yield multicall(this.web3, this.chainId, multicallCalls)).map(res => res[0]);
+        });
+    }
+    // Aave and Compound use 'user' for property name
+    getOwnerPropName() {
+        return this.protocol.id === ProtocolIdentifiers.LegacyAutomation.MakerDAO ? 'owner' : 'user';
+    }
+    _getSubscriptions(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let subscriptions = yield this.subscriptionsContract.contract.methods.getSubscribers().call();
+            if (addresses) {
+                const _addresses = addresses.map(a => a.toLowerCase());
+                // @ts-ignore
+                subscriptions = subscriptions.filter(s => _addresses.includes(s[this.getOwnerPropName()]));
+            }
+            return subscriptions;
+        });
+    }
+    getParsedSubscriptions(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let subscriptions = yield this._getSubscriptions(addresses);
+            // @ts-ignore
+            subscriptions = subscriptions.map(sub => ({
+                chainId: this.chainId,
+                owner: sub[this.getOwnerPropName()],
+                isEnabled: true,
+                protocol: this.protocol,
+                specific: Object.assign({}, sub),
+            }));
+            return subscriptions;
+        });
+    }
+    getSubscriptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getParsedSubscriptions();
+        });
+    }
+    getSubscriptionsFor(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getParsedSubscriptions(addresses);
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { Interfaces } from '../../types';
+import type { ProtocolIdentifiers } from '../../types/enums';
+export default class Protocol implements Interfaces.LegacyProtocol {
+    #private;
+    id: ProtocolIdentifiers.LegacyAutomation;
+    name: string;
+    version: string;
+    fullName: string;
+    constructor(args: {
+        id: ProtocolIdentifiers.LegacyAutomation;
+    });
+    private hasVersion;
+    private splitId;
+    /**
+     * @dev See naming convention at ProtocolIdentifiers declaration
+     */
+    private getVersion;
+    private getName;
+    private getFullName;
+}

package/esm/automation/private/LegacyProtocol.js

@@ -0,0 +1,34 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Protocol_versionSeparator;
+export default class Protocol {
+    constructor(args) {
+        _Protocol_versionSeparator.set(this, '__');
+        this.id = args.id;
+        this.name = this.getName();
+        this.version = this.getVersion();
+        this.fullName = this.getFullName();
+    }
+    hasVersion() {
+        return this.id.indexOf(__classPrivateFieldGet(this, _Protocol_versionSeparator, "f")) !== -1;
+    }
+    splitId() {
+        return this.id.split(__classPrivateFieldGet(this, _Protocol_versionSeparator, "f"));
+    }
+    /**
+     * @dev See naming convention at ProtocolIdentifiers declaration
+     */
+    getVersion() {
+        return this.hasVersion() ? this.splitId().reverse()[0] : '';
+    }
+    getName() {
+        return this.hasVersion() ? this.splitId()[0] : this.id;
+    }
+    getFullName() {
+        return this.hasVersion() ? `${this.name} ${this.version}` : this.name;
+    }
+}
+_Protocol_versionSeparator = new WeakMap();

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

@@ -0,0 +1,20 @@
+import type { Interfaces } from '../../types';
+import type { ProtocolIdentifiers } from '../../types/enums';
+export default class Protocol implements Interfaces.Protocol {
+    #private;
+    id: ProtocolIdentifiers.StrategiesAutomation;
+    name: string;
+    version: string;
+    fullName: string;
+    constructor(args: {
+        id: ProtocolIdentifiers.StrategiesAutomation;
+    });
+    private hasVersion;
+    private splitId;
+    /**
+     * @dev See naming convention at ProtocolIdentifiers declaration
+     */
+    private getVersion;
+    private getName;
+    private getFullName;
+}

package/esm/automation/private/Protocol.js

@@ -0,0 +1,34 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Protocol_versionSeparator;
+export default class Protocol {
+    constructor(args) {
+        _Protocol_versionSeparator.set(this, '__');
+        this.id = args.id;
+        this.name = this.getName();
+        this.version = this.getVersion();
+        this.fullName = this.getFullName();
+    }
+    hasVersion() {
+        return this.id.indexOf(__classPrivateFieldGet(this, _Protocol_versionSeparator, "f")) !== -1;
+    }
+    splitId() {
+        return this.id.split(__classPrivateFieldGet(this, _Protocol_versionSeparator, "f"));
+    }
+    /**
+     * @dev See naming convention at ProtocolIdentifiers declaration
+     */
+    getVersion() {
+        return this.hasVersion() ? this.splitId().reverse()[0] : '';
+    }
+    getName() {
+        return this.hasVersion() ? this.splitId()[0] : this.id;
+    }
+    getFullName() {
+        return this.hasVersion() ? `${this.name} ${this.version}` : this.name;
+    }
+}
+_Protocol_versionSeparator = new WeakMap();

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

@@ -0,0 +1,24 @@
+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';
+interface IStrategiesAutomation extends Interfaces.Automation {
+    chainId: ChainId;
+}
+export default class StrategiesAutomation extends Automation {
+    protected chainId: ChainId;
+    protected web3: Web3;
+    protected subStorageContract: Contract.WithMeta<SubStorage>;
+    constructor(args: IStrategiesAutomation);
+    protected getEventFromSubStorage(event: string, options?: PastEventOptions): Promise<import("web3-eth-contract").EventData[]>;
+    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 getParsedSubscriptions(parseData: ParseData): Position.Automated | null;
+    protected _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
+    getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
+    getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]>;
+}
+export {};

package/esm/automation/private/StrategiesAutomation.js

@@ -0,0 +1,111 @@
+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 { addToArrayIf, 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';
+export default class StrategiesAutomation extends Automation {
+    constructor(args) {
+        super();
+        this.web3 = args.provider;
+        this.chainId = args.chainId;
+        this.subStorageContract = makeSubStorageContract(this.web3, this.chainId);
+        this.assert();
+    }
+    getEventFromSubStorage(event, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return getEventsFromContract(this.subStorageContract, 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);
+        });
+    }
+    getSubscriptionEventsFromSubStorage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getEventFromSubStorage('Subscribe', options);
+        });
+    }
+    getUpdateDataEventsFromSubStorage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getEventFromSubStorage('UpdateData', options);
+        });
+    }
+    getParsedSubscriptions(parseData) {
+        return parseStrategiesAutomatedPosition(parseData);
+    }
+    _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 } }));
+            const subscriptionEvents = (yield this.getSubscriptionEventsFromSubStorage(_options)).map(e => e.returnValues); // TODO PlaceholderType
+            let subscriptions = [];
+            if (subscriptionEvents) {
+                // @ts-ignore
+                const strategiesSubs = yield this.getStrategiesSubs(subscriptionEvents.map((e) => e.subId));
+                subscriptions = yield Promise.all(strategiesSubs.map((sub, index) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    let latestUpdate = subscriptionEvents[index];
+                    if (latestUpdate.subHash !== (sub === null || sub === void 0 ? void 0 : sub.strategySubHash)) {
+                        const updates = yield this.getUpdateDataEventsFromSubStorage({ filter: 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({
+                        chainId: this.chainId,
+                        subscriptionEventData: latestUpdate,
+                        strategiesSubsData: sub,
+                    });
+                })));
+                if (options === null || options === void 0 ? void 0 : options.mergeWithSameId) {
+                    subscriptions = subscriptions.reduce((list, current) => {
+                        const copyList = [...list];
+                        if (isDefined(current)) {
+                            if (current.specific.mergeWithSameId) {
+                                const mergePairIndex = copyList.findIndex(s => (s && s.specific.mergeWithSameId
+                                    && s.strategy.strategyId === current.strategy.strategyId
+                                    && s.protocol.id === current.protocol.id));
+                                if (mergePairIndex !== -1) {
+                                    const mergePair = copyList[mergePairIndex];
+                                    if (isDefined(mergePair)) {
+                                        copyList[mergePairIndex] = Object.assign(Object.assign(Object.assign({}, mergePair), current), { isEnabled: mergePair.isEnabled || current.isEnabled, subId: mergePair.subId, subIds: [...addToArrayIf(isDefined(mergePair.subIds), mergePair.subIds), current.subId], specific: Object.assign(Object.assign(Object.assign({}, mergePair.specific), current.specific), { mergeWithSameId: false }) });
+                                        return copyList;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            return copyList;
+                        }
+                        copyList.push(Object.assign(Object.assign({}, current), { subIds: [current.subId] }));
+                        return copyList;
+                    }, []);
+                }
+            }
+            return subscriptions;
+        });
+    }
+    getSubscriptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._getSubscriptions(undefined, options);
+        });
+    }
+    getSubscriptionsFor(addresses, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._getSubscriptions(addresses, options);
+        });
+    }
+}

package/esm/automation/public/ArbitrumStrategies.d.ts

@@ -0,0 +1,5 @@
+import type { Interfaces } from '../../types';
+import StrategiesAutomation from '../private/StrategiesAutomation';
+export default class ArbitrumStrategies extends StrategiesAutomation {
+    constructor(args: Interfaces.Automation);
+}

package/esm/automation/public/ArbitrumStrategies.js

@@ -0,0 +1,7 @@
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+export default class ArbitrumStrategies extends StrategiesAutomation {
+    constructor(args) {
+        super(Object.assign(Object.assign({}, args), { chainId: ChainId.Arbitrum }));
+    }
+}

package/esm/automation/public/EthereumStrategies.d.ts

@@ -0,0 +1,5 @@
+import type { Interfaces } from '../../types';
+import StrategiesAutomation from '../private/StrategiesAutomation';
+export default class EthereumStrategies extends StrategiesAutomation {
+    constructor(args: Interfaces.Automation);
+}

package/esm/automation/public/EthereumStrategies.js

@@ -0,0 +1,7 @@
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+export default class EthereumStrategies extends StrategiesAutomation {
+    constructor(args) {
+        super(Object.assign(Object.assign({}, args), { chainId: ChainId.Ethereum }));
+    }
+}

package/esm/automation/public/OptimismStrategies.d.ts

@@ -0,0 +1,5 @@
+import type { Interfaces } from '../../types';
+import StrategiesAutomation from '../private/StrategiesAutomation';
+export default class OptimismStrategies extends StrategiesAutomation {
+    constructor(args: Interfaces.Automation);
+}

package/esm/automation/public/OptimismStrategies.js

@@ -0,0 +1,7 @@
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+export default class OptimismStrategies extends StrategiesAutomation {
+    constructor(args) {
+        super(Object.assign(Object.assign({}, args), { chainId: ChainId.Optimism }));
+    }
+}

package/esm/automation/public/legacy/LegacyAaveAutomation.d.ts

@@ -0,0 +1,6 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_AaveV2Subscriptions } from '../../../types/contracts/generated';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyAaveAutomation extends LegacyAutomation {
+    constructor(args: Interfaces.LegacyAutomation<Legacy_AaveV2Subscriptions>);
+}

package/esm/automation/public/legacy/LegacyAaveAutomation.js

@@ -0,0 +1,14 @@
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { AaveV2SubscriptionsJson } from '../../../abis';
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyAaveAutomation extends LegacyAutomation {
+    constructor(args) {
+        super({
+            provider: args.provider,
+            subscriptionsJson: makeLegacySubscriptionContract(args.provider, AaveV2SubscriptionsJson),
+            monitorAddress: '0x380982902872836ceC629171DaeAF42EcC02226e',
+            protocol: LEGACY_PROTOCOLS.AaveV2,
+        });
+    }
+}

package/esm/automation/public/legacy/LegacyCompoundAutomation.d.ts

@@ -0,0 +1,6 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_CompoundV2Subscriptions } from '../../../types/contracts/generated';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyAaveAutomation extends LegacyAutomation {
+    constructor(args: Interfaces.LegacyAutomation<Legacy_CompoundV2Subscriptions>);
+}

package/esm/automation/public/legacy/LegacyCompoundAutomation.js

@@ -0,0 +1,14 @@
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { CompoundV2SubscriptionsJson } from '../../../abis';
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyAaveAutomation extends LegacyAutomation {
+    constructor(args) {
+        super({
+            provider: args.provider,
+            subscriptionsJson: makeLegacySubscriptionContract(args.provider, CompoundV2SubscriptionsJson),
+            monitorAddress: '0xB1cF8DE8e791E4Ed1Bd86c03E2fc1f14389Cb10a',
+            protocol: LEGACY_PROTOCOLS.CompoundV2,
+        });
+    }
+}

package/esm/automation/public/legacy/LegacyMakerAutomation.d.ts

@@ -0,0 +1,6 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_MakerSubscriptions } from '../../../types/contracts/generated';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyMakerAutomation extends LegacyAutomation {
+    constructor(args: Interfaces.LegacyAutomation<Legacy_MakerSubscriptions>);
+}

package/esm/automation/public/legacy/LegacyMakerAutomation.js

@@ -0,0 +1,14 @@
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { MakerSubscriptionsJson } from '../../../abis';
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+import LegacyAutomation from '../../private/LegacyAutomation';
+export default class LegacyMakerAutomation extends LegacyAutomation {
+    constructor(args) {
+        super({
+            provider: args.provider,
+            subscriptionsJson: makeLegacySubscriptionContract(args.provider, MakerSubscriptionsJson),
+            monitorAddress: '0x1816A86C4DA59395522a42b871bf11A4E96A1C7a',
+            protocol: LEGACY_PROTOCOLS.MakerDAO,
+        });
+    }
+}

package/esm/configuration.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/configuration.js

@@ -0,0 +1,9 @@
+import Web3 from 'web3';
+import Dec from 'decimal.js';
+process.mockedWeb3 = new Web3('');
+Dec.set({
+    rounding: Dec.ROUND_DOWN,
+    toExpPos: 9e15,
+    toExpNeg: -9e15,
+    precision: 100,
+});

package/esm/constants/index.d.ts

@@ -0,0 +1,23 @@
+import type { ArbitrumBundleInfo, BundlesInfo, EthereumAddress, Interfaces, MainnetBundleInfo, MainnetStrategiesInfo, OptimismBundleInfo, StrategiesInfo } from '../types';
+import { ProtocolIdentifiers, Strategies, Bundles } from '../types/enums';
+export declare const ZERO_ADDRESS: EthereumAddress;
+export declare const PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.StrategiesAutomation, Interfaces.Protocol>;
+export declare const LEGACY_PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.LegacyAutomation, Interfaces.LegacyProtocol>;
+export declare const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo;
+export declare const OPTIMISM_STRATEGIES_INFO: {};
+export declare const ARBITRUM_STRATEGIES_INFO: {};
+export declare const STRATEGIES_INFO: StrategiesInfo;
+export declare const STRATEGY_IDS: {
+    1: typeof Strategies.MainnetIds;
+    10: typeof Strategies.OptimismIds;
+    42161: typeof Strategies.ArbitrumIds;
+};
+export declare const MAINNET_BUNDLES_INFO: MainnetBundleInfo;
+export declare const OPTIMISM_BUNDLES_INFO: OptimismBundleInfo;
+export declare const ARBITRUM_BUNDLES_INFO: ArbitrumBundleInfo;
+export declare const BUNDLES_INFO: BundlesInfo;
+export declare const BUNDLE_IDS: {
+    1: typeof Bundles.MainnetIds;
+    10: typeof Bundles.OptimismIds;
+    42161: typeof Bundles.ArbitrumIds;
+};