@defisaver/automation-sdk 1.0.1

package/esm/types/contracts/generated/SubStorage.d.ts

@@ -0,0 +1,114 @@
+/// <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 declare namespace StrategyModel {
+    type StrategySubStruct = [number | string | BN, boolean, string | number[][], string | number[][]] | {
+        strategyOrBundleId: number | string | BN;
+        isBundle: boolean;
+        triggerData: string | number[][];
+        subData: string | number[][];
+    };
+    type StrategySubStructOutputArray = [
+        string,
+        boolean,
+        string[],
+        string[]
+    ];
+    type StrategySubStructOutputStruct = {
+        strategyOrBundleId: string;
+        isBundle: boolean;
+        triggerData: string[];
+        subData: string[];
+    };
+    type StrategySubStructOutput = StrategySubStructOutputArray & StrategySubStructOutputStruct;
+    type StoredSubDataStruct = [string | number[], boolean, string | number[]] | {
+        userProxy: string | number[];
+        isEnabled: boolean;
+        strategySubHash: string | number[];
+    };
+    type StoredSubDataStructOutputArray = [string, boolean, string];
+    type StoredSubDataStructOutputStruct = {
+        userProxy: string;
+        isEnabled: boolean;
+        strategySubHash: string;
+    };
+    type StoredSubDataStructOutput = StoredSubDataStructOutputArray & StoredSubDataStructOutputStruct;
+}
+export type ActivateSub = ContractEventLog<{
+    subId: string;
+    0: string;
+}>;
+export type DeactivateSub = ContractEventLog<{
+    subId: string;
+    0: string;
+}>;
+export type Subscribe = ContractEventLog<{
+    subId: string;
+    proxy: string;
+    subHash: string;
+    subStruct: StrategyModel.StrategySubStructOutput;
+    0: string;
+    1: string;
+    2: string;
+    3: StrategyModel.StrategySubStructOutput;
+}>;
+export type UpdateData = ContractEventLog<{
+    subId: string;
+    subHash: string;
+    subStruct: StrategyModel.StrategySubStructOutput;
+    0: string;
+    1: string;
+    2: StrategyModel.StrategySubStructOutput;
+}>;
+export interface SubStorage extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): SubStorage;
+    clone(): SubStorage;
+    methods: {
+        activateSub(_subId: number | string | BN): NonPayableTransactionObject<void>;
+        adminVault(): NonPayableTransactionObject<string>;
+        deactivateSub(_subId: number | string | BN): NonPayableTransactionObject<void>;
+        getSub(_subId: number | string | BN): NonPayableTransactionObject<StrategyModel.StoredSubDataStructOutput>;
+        getSubsCount(): NonPayableTransactionObject<string>;
+        kill(): NonPayableTransactionObject<void>;
+        registry(): NonPayableTransactionObject<string>;
+        strategiesSubs(arg0: number | string | BN): NonPayableTransactionObject<[
+            string,
+            boolean,
+            string
+        ] & {
+            userProxy: string;
+            isEnabled: boolean;
+            strategySubHash: string;
+        }>;
+        subscribeToStrategy(_sub: StrategyModel.StrategySubStruct): NonPayableTransactionObject<string>;
+        updateSubData(_subId: number | string | BN, _sub: StrategyModel.StrategySubStruct): NonPayableTransactionObject<void>;
+        withdrawStuckFunds(_token: string, _receiver: string, _amount: number | string | BN): NonPayableTransactionObject<void>;
+    };
+    events: {
+        ActivateSub(cb?: Callback<ActivateSub>): EventEmitter;
+        ActivateSub(options?: EventOptions, cb?: Callback<ActivateSub>): EventEmitter;
+        DeactivateSub(cb?: Callback<DeactivateSub>): EventEmitter;
+        DeactivateSub(options?: EventOptions, cb?: Callback<DeactivateSub>): EventEmitter;
+        Subscribe(cb?: Callback<Subscribe>): EventEmitter;
+        Subscribe(options?: EventOptions, cb?: Callback<Subscribe>): EventEmitter;
+        UpdateData(cb?: Callback<UpdateData>): EventEmitter;
+        UpdateData(options?: EventOptions, cb?: Callback<UpdateData>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "ActivateSub", cb: Callback<ActivateSub>): void;
+    once(event: "ActivateSub", options: EventOptions, cb: Callback<ActivateSub>): void;
+    once(event: "DeactivateSub", cb: Callback<DeactivateSub>): void;
+    once(event: "DeactivateSub", options: EventOptions, cb: Callback<DeactivateSub>): void;
+    once(event: "Subscribe", cb: Callback<Subscribe>): void;
+    once(event: "Subscribe", options: EventOptions, cb: Callback<Subscribe>): void;
+    once(event: "UpdateData", cb: Callback<UpdateData>): void;
+    once(event: "UpdateData", options: EventOptions, cb: Callback<UpdateData>): void;
+}

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

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export {};

package/esm/types/contracts/generated/UniMulticall.d.ts

@@ -0,0 +1,55 @@
+/// <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, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare namespace UniswapInterfaceMulticall {
+    type CallStruct = [string, number | string | BN, string | number[]] | {
+        target: string;
+        gasLimit: number | string | BN;
+        callData: string | number[];
+    };
+    type CallStructOutputArray = [string, string, string];
+    type CallStructOutputStruct = {
+        target: string;
+        gasLimit: string;
+        callData: string;
+    };
+    type CallStructOutput = CallStructOutputArray & CallStructOutputStruct;
+    type ResultStruct = [boolean, number | string | BN, string | number[]] | {
+        success: boolean;
+        gasUsed: number | string | BN;
+        returnData: string | number[];
+    };
+    type ResultStructOutputArray = [boolean, string, string];
+    type ResultStructOutputStruct = {
+        success: boolean;
+        gasUsed: string;
+        returnData: string;
+    };
+    type ResultStructOutput = ResultStructOutputArray & ResultStructOutputStruct;
+}
+export interface UniMulticall extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): UniMulticall;
+    clone(): UniMulticall;
+    methods: {
+        getCurrentBlockTimestamp(): NonPayableTransactionObject<string>;
+        getEthBalance(addr: string): NonPayableTransactionObject<string>;
+        multicall(calls: UniswapInterfaceMulticall.CallStruct[]): NonPayableTransactionObject<[
+            string,
+            UniswapInterfaceMulticall.ResultStructOutput[]
+        ] & {
+            blockNumber: string;
+            returnData: UniswapInterfaceMulticall.ResultStructOutput[];
+        }>;
+    };
+    events: {
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+}

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

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export {};

package/esm/types/contracts/generated/index.d.ts

@@ -0,0 +1,7 @@
+export type { Erc20 } from "./Erc20";
+export type { SubStorage } from "./SubStorage";
+export type { UniMulticall } from "./UniMulticall";
+export type { Legacy_AaveV2Subscriptions } from "./Legacy_AaveV2Subscriptions";
+export type { Legacy_AuthCheck } from "./Legacy_AuthCheck";
+export type { Legacy_CompoundV2Subscriptions } from "./Legacy_CompoundV2Subscriptions";
+export type { Legacy_MakerSubscriptions } from "./Legacy_MakerSubscriptions";

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

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

package/esm/types/contracts/generated/types.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { EventEmitter } from "events";
+import type { EventLog, PromiEvent, TransactionReceipt } from "web3-core/types";
+import type { Contract } from "web3-eth-contract";
+export interface EstimateGasOptions {
+    from?: string;
+    gas?: number;
+    value?: number | string | BN;
+}
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export type Callback<T> = (error: Error, result: T) => void;
+export interface ContractEventLog<T> extends EventLog {
+    returnValues: T;
+}
+export interface ContractEventEmitter<T> extends EventEmitter {
+    on(event: "connected", listener: (subscriptionId: string) => void): this;
+    on(event: "data" | "changed", listener: (event: ContractEventLog<T>) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+}
+export interface NonPayableTx {
+    nonce?: string | number | BN;
+    chainId?: string | number | BN;
+    from?: string;
+    to?: string;
+    data?: string;
+    gas?: string | number | BN;
+    maxPriorityFeePerGas?: string | number | BN;
+    maxFeePerGas?: string | number | BN;
+    gasPrice?: string | number | BN;
+}
+export interface PayableTx extends NonPayableTx {
+    value?: string | number | BN;
+}
+export interface NonPayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: NonPayableTx, block?: BlockType): Promise<T>;
+    send(tx?: NonPayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: NonPayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export interface PayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: PayableTx, block?: BlockType): Promise<T>;
+    send(tx?: PayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: PayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export type BlockType = "latest" | "pending" | "genesis" | "earliest" | number | BN;
+export type BaseContract = Omit<Contract, "clone" | "once">;

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

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

package/esm/types/enums.d.ts

@@ -0,0 +1,97 @@
+export declare enum ChainId {
+    Ethereum = 1,
+    Optimism = 10,
+    Arbitrum = 42161
+}
+export declare enum RatioState {
+    OVER = 0,
+    UNDER = 1
+}
+export declare enum BundleProtocols {
+    MStable = "mstable",
+    Yearn = "yearn",
+    Rari = "rari"
+}
+/**
+ * @dev Follow the naming convention:
+ *      - Enum name consists of two parts, name and version
+ *      - Name should be human-readable name of the protocol, it can include spaces or any characters needed
+ *      - 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 declare namespace ProtocolIdentifiers {
+    enum StrategiesAutomation {
+        MakerDAO = "MakerDAO__MCD",
+        Liquity = "Liquity",
+        ChickenBonds = "ChickenBonds",
+        CompoundV3 = "Compound__V3",
+        AaveV3 = "Aave__V3"
+    }
+    enum LegacyAutomation {
+        MakerDAO = "MakerDAO__MCD",
+        CompoundV2 = "Compound__V2",
+        AaveV2 = "Aave__V2"
+    }
+}
+export declare namespace Strategies {
+    enum MainnetIds {
+        MAKER_CLOSE_ON_PRICE_TO_DAI = 7,
+        MAKER_CLOSE_ON_PRICE_TO_COLL = 9,
+        LIQUITY_CLOSE_ON_PRICE_TO_COLL_DEPRECATED = 10,
+        MAKER_TRAILING_STOP_LOSS_TO_COLL = 11,
+        MAKER_TRAILING_STOP_LOSS_TO_DAI = 12,
+        LIQUITY_TRAILING_STOP_LOSS_TO_COLL = 13,
+        LIQUITY_CLOSE_ON_PRICE_TO_COLL = 14,
+        CHICKEN_BONDS_REBOND = 31
+    }
+    enum OptimismIds {
+    }
+    enum ArbitrumIds {
+    }
+    enum Identifiers {
+        SavingsLiqProtection = "smart-savings-liquidation-protection",
+        Repay = "repay",
+        EoaRepay = "eoa-repay",
+        Boost = "boost",
+        EoaBoost = "eoa-boost",
+        CloseToDebt = "close-to-debt",
+        CloseToCollateral = "close-to-collateral",
+        CloseOnPriceToDebt = "close-on-price-to-debt",
+        CloseOnPriceToColl = "close-on-price-to-collateral",
+        TrailingStopToColl = "trailing-stop-to-collateral",
+        TrailingStopToDebt = "trailing-stop-to-debt",
+        Rebond = "rebond",
+        BondProtection = "bond-protection"
+    }
+    enum IdOverrides {
+        TakeProfit = "take-profit",
+        StopLoss = "stop-loss",
+        TrailingStop = "trailing-stop",
+        LeverageManagement = "leverage-management",
+        EoaLeverageManagement = "leverage-management-eoa"
+    }
+}
+export declare namespace Bundles {
+    enum MainnetIds {
+        MAKER_REPAY_FROM_SMART_SAVINGS_YEARN = 0,
+        MAKER_REPAY_FROM_SMART_SAVINGS_MSTABLE = 1,
+        MAKER_REPAY_FROM_SMART_SAVINGS_RARI = 2,
+        COMP_V3_SW_REPAY_BUNDLE = 3,
+        COMP_V3_SW_BOOST_BUNDLE = 4,
+        COMP_V3_EOA_REPAY_BUNDLE = 5,
+        COMP_V3_EOA_BOOST_BUNDLE = 6,
+        LIQUITY_PAYBACK_USING_CHICKEN_BOND = 7
+    }
+    enum OptimismIds {
+        AAVE_V3_REPAY = 0,
+        AAVE_V3_BOOST = 1,
+        AAVE_V3_CLOSE_TO_DEBT = 2,
+        AAVE_V3_CLOSE_TO_COLLATERAL = 3
+    }
+    enum ArbitrumIds {
+        AAVE_V3_REPAY = 0,
+        AAVE_V3_BOOST = 1,
+        AAVE_V3_CLOSE_TO_DEBT = 2,
+        AAVE_V3_CLOSE_TO_COLLATERAL = 3
+    }
+}

package/esm/types/enums.js

@@ -0,0 +1,113 @@
+export var ChainId;
+(function (ChainId) {
+    ChainId[ChainId["Ethereum"] = 1] = "Ethereum";
+    ChainId[ChainId["Optimism"] = 10] = "Optimism";
+    ChainId[ChainId["Arbitrum"] = 42161] = "Arbitrum";
+})(ChainId || (ChainId = {}));
+export var RatioState;
+(function (RatioState) {
+    RatioState[RatioState["OVER"] = 0] = "OVER";
+    RatioState[RatioState["UNDER"] = 1] = "UNDER";
+})(RatioState || (RatioState = {}));
+export var BundleProtocols;
+(function (BundleProtocols) {
+    BundleProtocols["MStable"] = "mstable";
+    BundleProtocols["Yearn"] = "yearn";
+    BundleProtocols["Rari"] = "rari";
+})(BundleProtocols || (BundleProtocols = {}));
+/**
+ * @dev Follow the naming convention:
+ *      - Enum name consists of two parts, name and version
+ *      - Name should be human-readable name of the protocol, it can include spaces or any characters needed
+ *      - 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;
+(function (ProtocolIdentifiers) {
+    let StrategiesAutomation;
+    (function (StrategiesAutomation) {
+        StrategiesAutomation["MakerDAO"] = "MakerDAO__MCD";
+        StrategiesAutomation["Liquity"] = "Liquity";
+        StrategiesAutomation["ChickenBonds"] = "ChickenBonds";
+        StrategiesAutomation["CompoundV3"] = "Compound__V3";
+        StrategiesAutomation["AaveV3"] = "Aave__V3";
+    })(StrategiesAutomation = ProtocolIdentifiers.StrategiesAutomation || (ProtocolIdentifiers.StrategiesAutomation = {}));
+    let LegacyAutomation;
+    (function (LegacyAutomation) {
+        LegacyAutomation["MakerDAO"] = "MakerDAO__MCD";
+        LegacyAutomation["CompoundV2"] = "Compound__V2";
+        LegacyAutomation["AaveV2"] = "Aave__V2";
+    })(LegacyAutomation = ProtocolIdentifiers.LegacyAutomation || (ProtocolIdentifiers.LegacyAutomation = {}));
+})(ProtocolIdentifiers || (ProtocolIdentifiers = {}));
+export var Strategies;
+(function (Strategies) {
+    let MainnetIds;
+    (function (MainnetIds) {
+        MainnetIds[MainnetIds["MAKER_CLOSE_ON_PRICE_TO_DAI"] = 7] = "MAKER_CLOSE_ON_PRICE_TO_DAI";
+        MainnetIds[MainnetIds["MAKER_CLOSE_ON_PRICE_TO_COLL"] = 9] = "MAKER_CLOSE_ON_PRICE_TO_COLL";
+        MainnetIds[MainnetIds["LIQUITY_CLOSE_ON_PRICE_TO_COLL_DEPRECATED"] = 10] = "LIQUITY_CLOSE_ON_PRICE_TO_COLL_DEPRECATED";
+        MainnetIds[MainnetIds["MAKER_TRAILING_STOP_LOSS_TO_COLL"] = 11] = "MAKER_TRAILING_STOP_LOSS_TO_COLL";
+        MainnetIds[MainnetIds["MAKER_TRAILING_STOP_LOSS_TO_DAI"] = 12] = "MAKER_TRAILING_STOP_LOSS_TO_DAI";
+        MainnetIds[MainnetIds["LIQUITY_TRAILING_STOP_LOSS_TO_COLL"] = 13] = "LIQUITY_TRAILING_STOP_LOSS_TO_COLL";
+        MainnetIds[MainnetIds["LIQUITY_CLOSE_ON_PRICE_TO_COLL"] = 14] = "LIQUITY_CLOSE_ON_PRICE_TO_COLL";
+        MainnetIds[MainnetIds["CHICKEN_BONDS_REBOND"] = 31] = "CHICKEN_BONDS_REBOND";
+    })(MainnetIds = Strategies.MainnetIds || (Strategies.MainnetIds = {}));
+    let OptimismIds;
+    (function (OptimismIds) {
+    })(OptimismIds = Strategies.OptimismIds || (Strategies.OptimismIds = {}));
+    let ArbitrumIds;
+    (function (ArbitrumIds) {
+    })(ArbitrumIds = Strategies.ArbitrumIds || (Strategies.ArbitrumIds = {}));
+    let Identifiers;
+    (function (Identifiers) {
+        Identifiers["SavingsLiqProtection"] = "smart-savings-liquidation-protection";
+        Identifiers["Repay"] = "repay";
+        Identifiers["EoaRepay"] = "eoa-repay";
+        Identifiers["Boost"] = "boost";
+        Identifiers["EoaBoost"] = "eoa-boost";
+        Identifiers["CloseToDebt"] = "close-to-debt";
+        Identifiers["CloseToCollateral"] = "close-to-collateral";
+        Identifiers["CloseOnPriceToDebt"] = "close-on-price-to-debt";
+        Identifiers["CloseOnPriceToColl"] = "close-on-price-to-collateral";
+        Identifiers["TrailingStopToColl"] = "trailing-stop-to-collateral";
+        Identifiers["TrailingStopToDebt"] = "trailing-stop-to-debt";
+        Identifiers["Rebond"] = "rebond";
+        Identifiers["BondProtection"] = "bond-protection";
+    })(Identifiers = Strategies.Identifiers || (Strategies.Identifiers = {}));
+    let IdOverrides;
+    (function (IdOverrides) {
+        IdOverrides["TakeProfit"] = "take-profit";
+        IdOverrides["StopLoss"] = "stop-loss";
+        IdOverrides["TrailingStop"] = "trailing-stop";
+        IdOverrides["LeverageManagement"] = "leverage-management";
+        IdOverrides["EoaLeverageManagement"] = "leverage-management-eoa";
+    })(IdOverrides = Strategies.IdOverrides || (Strategies.IdOverrides = {}));
+})(Strategies || (Strategies = {}));
+export var Bundles;
+(function (Bundles) {
+    let MainnetIds;
+    (function (MainnetIds) {
+        MainnetIds[MainnetIds["MAKER_REPAY_FROM_SMART_SAVINGS_YEARN"] = 0] = "MAKER_REPAY_FROM_SMART_SAVINGS_YEARN";
+        MainnetIds[MainnetIds["MAKER_REPAY_FROM_SMART_SAVINGS_MSTABLE"] = 1] = "MAKER_REPAY_FROM_SMART_SAVINGS_MSTABLE";
+        MainnetIds[MainnetIds["MAKER_REPAY_FROM_SMART_SAVINGS_RARI"] = 2] = "MAKER_REPAY_FROM_SMART_SAVINGS_RARI";
+        MainnetIds[MainnetIds["COMP_V3_SW_REPAY_BUNDLE"] = 3] = "COMP_V3_SW_REPAY_BUNDLE";
+        MainnetIds[MainnetIds["COMP_V3_SW_BOOST_BUNDLE"] = 4] = "COMP_V3_SW_BOOST_BUNDLE";
+        MainnetIds[MainnetIds["COMP_V3_EOA_REPAY_BUNDLE"] = 5] = "COMP_V3_EOA_REPAY_BUNDLE";
+        MainnetIds[MainnetIds["COMP_V3_EOA_BOOST_BUNDLE"] = 6] = "COMP_V3_EOA_BOOST_BUNDLE";
+        MainnetIds[MainnetIds["LIQUITY_PAYBACK_USING_CHICKEN_BOND"] = 7] = "LIQUITY_PAYBACK_USING_CHICKEN_BOND";
+    })(MainnetIds = Bundles.MainnetIds || (Bundles.MainnetIds = {}));
+    let OptimismIds;
+    (function (OptimismIds) {
+        OptimismIds[OptimismIds["AAVE_V3_REPAY"] = 0] = "AAVE_V3_REPAY";
+        OptimismIds[OptimismIds["AAVE_V3_BOOST"] = 1] = "AAVE_V3_BOOST";
+        OptimismIds[OptimismIds["AAVE_V3_CLOSE_TO_DEBT"] = 2] = "AAVE_V3_CLOSE_TO_DEBT";
+        OptimismIds[OptimismIds["AAVE_V3_CLOSE_TO_COLLATERAL"] = 3] = "AAVE_V3_CLOSE_TO_COLLATERAL";
+    })(OptimismIds = Bundles.OptimismIds || (Bundles.OptimismIds = {}));
+    let ArbitrumIds;
+    (function (ArbitrumIds) {
+        ArbitrumIds[ArbitrumIds["AAVE_V3_REPAY"] = 0] = "AAVE_V3_REPAY";
+        ArbitrumIds[ArbitrumIds["AAVE_V3_BOOST"] = 1] = "AAVE_V3_BOOST";
+        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 = {}));

package/esm/types/index.d.ts

@@ -0,0 +1,180 @@
+import type Web3 from 'web3';
+import type { AbiItem } from 'web3-utils';
+import type { BaseContract, BlockType } from './contracts/generated/types';
+import type { Subscribe, StrategyModel } from './contracts/generated/SubStorage';
+import type { ChainId, Strategies, Bundles, ProtocolIdentifiers, RatioState } from './enums';
+export type PlaceholderType = any;
+export type EthereumAddress = string;
+export type BlockNumber = BlockType;
+export declare namespace Utils {
+    type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    type WithRequired<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>;
+    type ValuesOf<E> = E[keyof E];
+    type EnumUnion<T> = {
+        [k in keyof T]: ValuesOf<T[k]>;
+    }[keyof T];
+}
+export declare namespace Contract {
+    interface Json {
+        abi: AbiItem[];
+        networks?: {
+            [key in ChainId as string]: {
+                createdBlock?: number;
+                address: EthereumAddress;
+            };
+        };
+    }
+    interface WithMeta<T> {
+        abi: AbiItem[];
+        address: EthereumAddress;
+        createdBlock: BlockNumber;
+        contract: T;
+    }
+}
+export declare namespace Multicall {
+    interface Calls {
+        abiItem: AbiItem;
+        target: EthereumAddress;
+        gasLimit?: number;
+        params: any[];
+    }
+    interface FormattedCalls {
+        callData: string;
+        target: EthereumAddress;
+        gasLimit: number;
+    }
+    type Payload = any[];
+}
+export interface SubscriptionOptions {
+    toBlock: BlockNumber;
+    fromBlock: BlockNumber;
+    mergeWithSameId?: boolean;
+}
+export declare namespace Interfaces {
+    interface ProtocolBase {
+        id: ProtocolIdentifiers.StrategiesAutomation | ProtocolIdentifiers.LegacyAutomation;
+        name: string;
+        fullName: string;
+        version: string;
+    }
+    interface Protocol extends ProtocolBase {
+        id: ProtocolIdentifiers.StrategiesAutomation;
+    }
+    interface LegacyProtocol extends ProtocolBase {
+        id: ProtocolIdentifiers.LegacyAutomation;
+    }
+    interface Automation {
+        provider: Web3;
+    }
+    interface LegacyAutomation<T extends BaseContract> {
+        provider: Web3;
+        monitorAddress: EthereumAddress;
+        protocol: Interfaces.LegacyProtocol;
+        subscriptionsJson: Contract.WithMeta<T>;
+    }
+}
+export interface Strategy {
+    strategyId: Strategies.Identifiers | Strategies.IdOverrides;
+    protocol: Interfaces.Protocol;
+    isBundle?: boolean;
+}
+export interface BundleOrStrategy extends Strategy {
+    bundleId?: string;
+    bundleName?: string;
+}
+export type TriggerData = StrategyModel.StrategySubStructOutputStruct['triggerData'];
+export type SubData = StrategyModel.StrategySubStructOutputStruct['subData'];
+export declare namespace Position {
+    namespace Specific {
+        interface Base {
+            subId1?: number;
+            subId2?: number;
+            mergeWithSameId?: boolean;
+        }
+        interface RatioProtection extends Base {
+            minRatio?: number;
+            minOptimalRatio?: number;
+            repayEnabled?: boolean;
+            maxRatio?: number;
+            maxOptimalRatio?: number;
+            boostEnabled?: boolean;
+        }
+        interface CloseOnPrice extends Base {
+            price: string;
+            closeToAssetAddr: EthereumAddress;
+        }
+        interface CloseOnPriceAave extends Base {
+            collAsset: EthereumAddress;
+            collAssetId: number;
+            debtAsset: EthereumAddress;
+            debtAssetId: number;
+            baseToken: EthereumAddress;
+            quoteToken: EthereumAddress;
+            price: string;
+            ratioState: RatioState;
+        }
+        interface TrailingStop extends Base {
+            roundId: number;
+            triggerPercentage: number;
+            closeToAssetAddr: EthereumAddress;
+        }
+    }
+    interface Automated {
+        chainId: ChainId;
+        owner: EthereumAddress;
+        subId: number;
+        subIds?: number[];
+        isEnabled?: boolean;
+        protocol: Interfaces.Protocol;
+        strategy: BundleOrStrategy;
+        strategyData: {
+            encoded: {
+                triggerData: TriggerData;
+                subData: SubData;
+            };
+            decoded: {
+                triggerData: PlaceholderType;
+                subData: PlaceholderType;
+            };
+        };
+        specific: Specific.CloseOnPrice | Specific.TrailingStop | Specific.RatioProtection | Specific.CloseOnPriceAave;
+    }
+    interface LegacyAutomated {
+        chainId: ChainId;
+        owner: EthereumAddress;
+        isEnabled: boolean;
+        protocol: Interfaces.LegacyProtocol;
+        specific: any;
+    }
+}
+type StrategyInfo<T extends number> = Record<T, Strategy>;
+export type MainnetStrategiesInfo = StrategyInfo<Strategies.MainnetIds>;
+export type OptimismStrategiesInfo = StrategyInfo<Strategies.OptimismIds>;
+export type ArbitrumStrategiesInfo = StrategyInfo<Strategies.ArbitrumIds>;
+type BundleInfo<T extends number> = Record<T, BundleOrStrategy>;
+export type MainnetBundleInfo = BundleInfo<Bundles.MainnetIds>;
+export type OptimismBundleInfo = BundleInfo<Bundles.OptimismIds>;
+export type ArbitrumBundleInfo = BundleInfo<Bundles.ArbitrumIds>;
+export interface StrategiesInfo {
+    [ChainId.Ethereum]: MainnetStrategiesInfo;
+    [ChainId.Optimism]: OptimismStrategiesInfo;
+    [ChainId.Arbitrum]: ArbitrumStrategiesInfo;
+}
+export interface BundlesInfo {
+    [ChainId.Ethereum]: MainnetBundleInfo;
+    [ChainId.Optimism]: OptimismBundleInfo;
+    [ChainId.Arbitrum]: ArbitrumBundleInfo;
+}
+export type StrategyOrBundleIds = Strategies.MainnetIds & Strategies.OptimismIds & Strategies.ArbitrumIds & Bundles.MainnetIds & Bundles.OptimismIds & Bundles.ArbitrumIds;
+export interface ParseData {
+    chainId: ChainId;
+    subscriptionEventData: Subscribe['returnValues'];
+    strategiesSubsData: StrategyModel.StoredSubDataStructOutputStruct;
+}
+type MapToProtocolVersion<T> = {
+    [i in ProtocolIdentifiers.StrategiesAutomation]: {
+        [key in Strategies.Identifiers as string]: T;
+    };
+};
+export type StrategiesToProtocolVersionMapping = MapToProtocolVersion<(position: Position.Automated, parseData: ParseData) => Position.Automated>;
+export {};

package/esm/types/index.js

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