@mean-finance/dca-v2-periphery/dist/contracts/interfaces/IDCAFeeManager.d.ts

💱 Periphery smart contracts of DCA V2 by mean.finance

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
export declare type AllowanceStruct = {
    token: PromiseOrValue<string>;
    allowanceTarget: PromiseOrValue<string>;
    minAllowance: PromiseOrValue<BigNumberish>;
};
export declare type AllowanceStructOutput = [string, string, BigNumber] & {
    token: string;
    allowanceTarget: string;
    minAllowance: BigNumber;
};
export declare type SwapContextStruct = {
    swapperIndex: PromiseOrValue<BigNumberish>;
    value: PromiseOrValue<BigNumberish>;
};
export declare type SwapContextStructOutput = [number, BigNumber] & {
    swapperIndex: number;
    value: BigNumber;
};
export declare type TransferOutBalanceStruct = {
    token: PromiseOrValue<string>;
    recipient: PromiseOrValue<string>;
};
export declare type TransferOutBalanceStructOutput = [string, string] & {
    token: string;
    recipient: string;
};
export declare namespace IDCAFeeManager {
    type PositionBalanceStruct = {
        positionId: PromiseOrValue<BigNumberish>;
        from: PromiseOrValue<string>;
        to: PromiseOrValue<string>;
        swapped: PromiseOrValue<BigNumberish>;
        remaining: PromiseOrValue<BigNumberish>;
    };
    type PositionBalanceStructOutput = [
        BigNumber,
        string,
        string,
        BigNumber,
        BigNumber
    ] & {
        positionId: BigNumber;
        from: string;
        to: string;
        swapped: BigNumber;
        remaining: BigNumber;
    };
    type AvailableBalanceStruct = {
        token: PromiseOrValue<string>;
        platformBalance: PromiseOrValue<BigNumberish>;
        feeManagerBalance: PromiseOrValue<BigNumberish>;
        positions: IDCAFeeManager.PositionBalanceStruct[];
    };
    type AvailableBalanceStructOutput = [
        string,
        BigNumber,
        BigNumber,
        IDCAFeeManager.PositionBalanceStructOutput[]
    ] & {
        token: string;
        platformBalance: BigNumber;
        feeManagerBalance: BigNumber;
        positions: IDCAFeeManager.PositionBalanceStructOutput[];
    };
    type AmountToFillStruct = {
        token: PromiseOrValue<string>;
        amountOfSwaps: PromiseOrValue<BigNumberish>;
        amount: PromiseOrValue<BigNumberish>;
    };
    type AmountToFillStructOutput = [string, number, BigNumber] & {
        token: string;
        amountOfSwaps: number;
        amount: BigNumber;
    };
    type TargetTokenShareStruct = {
        token: PromiseOrValue<string>;
        shares: PromiseOrValue<BigNumberish>;
    };
    type TargetTokenShareStructOutput = [string, number] & {
        token: string;
        shares: number;
    };
    type RunSwapsAndTransferManyParamsStruct = {
        allowanceTargets: AllowanceStruct[];
        swappers: PromiseOrValue<string>[];
        swaps: PromiseOrValue<BytesLike>[];
        swapContext: SwapContextStruct[];
        transferOutBalance: TransferOutBalanceStruct[];
    };
    type RunSwapsAndTransferManyParamsStructOutput = [
        AllowanceStructOutput[],
        string[],
        string[],
        SwapContextStructOutput[],
        TransferOutBalanceStructOutput[]
    ] & {
        allowanceTargets: AllowanceStructOutput[];
        swappers: string[];
        swaps: string[];
        swapContext: SwapContextStructOutput[];
        transferOutBalance: TransferOutBalanceStructOutput[];
    };
}
export declare namespace ISwapAdapter {
    type RevokeActionStruct = {
        spender: PromiseOrValue<string>;
        tokens: PromiseOrValue<string>[];
    };
    type RevokeActionStructOutput = [string, string[]] & {
        spender: string;
        tokens: string[];
    };
}
export declare namespace IDCAHub {
    type AmountOfTokenStruct = {
        token: PromiseOrValue<string>;
        amount: PromiseOrValue<BigNumberish>;
    };
    type AmountOfTokenStructOutput = [string, BigNumber] & {
        token: string;
        amount: BigNumber;
    };
}
export declare namespace IDCAHubPositionHandler {
    type PositionSetStruct = {
        token: PromiseOrValue<string>;
        positionIds: PromiseOrValue<BigNumberish>[];
    };
    type PositionSetStructOutput = [string, BigNumber[]] & {
        token: string;
        positionIds: BigNumber[];
    };
}
export interface IDCAFeeManagerInterface extends utils.Interface {
    functions: {
        "MAX_TOKEN_TOTAL_SHARE()": FunctionFragment;
        "SWAP_INTERVAL()": FunctionFragment;
        "availableBalances(address,address[])": FunctionFragment;
        "fillPositions(address,(address,uint32,uint256)[],(address,uint16)[])": FunctionFragment;
        "positions(bytes32)": FunctionFragment;
        "revokeAllowances((address,address[])[])": FunctionFragment;
        "runSwapsAndTransferMany(((address,address,uint256)[],address[],bytes[],(uint8,uint256)[],(address,address)[]))": FunctionFragment;
        "terminatePositions(address,uint256[],address)": FunctionFragment;
        "withdrawFromBalance((address,uint256)[],address)": FunctionFragment;
        "withdrawFromPlatformBalance(address,(address,uint256)[],address)": FunctionFragment;
        "withdrawFromPositions(address,(address,uint256[])[],address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "MAX_TOKEN_TOTAL_SHARE" | "SWAP_INTERVAL" | "availableBalances" | "fillPositions" | "positions" | "revokeAllowances" | "runSwapsAndTransferMany" | "terminatePositions" | "withdrawFromBalance" | "withdrawFromPlatformBalance" | "withdrawFromPositions"): FunctionFragment;
    encodeFunctionData(functionFragment: "MAX_TOKEN_TOTAL_SHARE", values?: undefined): string;
    encodeFunctionData(functionFragment: "SWAP_INTERVAL", values?: undefined): string;
    encodeFunctionData(functionFragment: "availableBalances", values: [PromiseOrValue<string>, PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "fillPositions", values: [
        PromiseOrValue<string>,
        IDCAFeeManager.AmountToFillStruct[],
        IDCAFeeManager.TargetTokenShareStruct[]
    ]): string;
    encodeFunctionData(functionFragment: "positions", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "revokeAllowances", values: [ISwapAdapter.RevokeActionStruct[]]): string;
    encodeFunctionData(functionFragment: "runSwapsAndTransferMany", values: [IDCAFeeManager.RunSwapsAndTransferManyParamsStruct]): string;
    encodeFunctionData(functionFragment: "terminatePositions", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>[],
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "withdrawFromBalance", values: [IDCAHub.AmountOfTokenStruct[], PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "withdrawFromPlatformBalance", values: [
        PromiseOrValue<string>,
        IDCAHub.AmountOfTokenStruct[],
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "withdrawFromPositions", values: [
        PromiseOrValue<string>,
        IDCAHubPositionHandler.PositionSetStruct[],
        PromiseOrValue<string>
    ]): string;
    decodeFunctionResult(functionFragment: "MAX_TOKEN_TOTAL_SHARE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "SWAP_INTERVAL", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "availableBalances", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fillPositions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "positions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revokeAllowances", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "runSwapsAndTransferMany", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "terminatePositions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFromBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFromPlatformBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFromPositions", data: BytesLike): Result;
    events: {};
}
export interface IDCAFeeManager extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IDCAFeeManagerInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        MAX_TOKEN_TOTAL_SHARE(overrides?: CallOverrides): Promise<[number]>;
        SWAP_INTERVAL(overrides?: CallOverrides): Promise<[number]>;
        availableBalances(hub: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[IDCAFeeManager.AvailableBalanceStructOutput[]]>;
        fillPositions(hub: PromiseOrValue<string>, amounts: IDCAFeeManager.AmountToFillStruct[], distribution: IDCAFeeManager.TargetTokenShareStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        positions(pairKey: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
        revokeAllowances(revokeActions: ISwapAdapter.RevokeActionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        runSwapsAndTransferMany(parameters: IDCAFeeManager.RunSwapsAndTransferManyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        terminatePositions(hub: PromiseOrValue<string>, positionIds: PromiseOrValue<BigNumberish>[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFromBalance(amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFromPlatformBalance(hub: PromiseOrValue<string>, amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFromPositions(hub: PromiseOrValue<string>, positionSets: IDCAHubPositionHandler.PositionSetStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    MAX_TOKEN_TOTAL_SHARE(overrides?: CallOverrides): Promise<number>;
    SWAP_INTERVAL(overrides?: CallOverrides): Promise<number>;
    availableBalances(hub: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<IDCAFeeManager.AvailableBalanceStructOutput[]>;
    fillPositions(hub: PromiseOrValue<string>, amounts: IDCAFeeManager.AmountToFillStruct[], distribution: IDCAFeeManager.TargetTokenShareStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    positions(pairKey: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    revokeAllowances(revokeActions: ISwapAdapter.RevokeActionStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    runSwapsAndTransferMany(parameters: IDCAFeeManager.RunSwapsAndTransferManyParamsStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    terminatePositions(hub: PromiseOrValue<string>, positionIds: PromiseOrValue<BigNumberish>[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFromBalance(amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFromPlatformBalance(hub: PromiseOrValue<string>, amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFromPositions(hub: PromiseOrValue<string>, positionSets: IDCAHubPositionHandler.PositionSetStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        MAX_TOKEN_TOTAL_SHARE(overrides?: CallOverrides): Promise<number>;
        SWAP_INTERVAL(overrides?: CallOverrides): Promise<number>;
        availableBalances(hub: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<IDCAFeeManager.AvailableBalanceStructOutput[]>;
        fillPositions(hub: PromiseOrValue<string>, amounts: IDCAFeeManager.AmountToFillStruct[], distribution: IDCAFeeManager.TargetTokenShareStruct[], overrides?: CallOverrides): Promise<void>;
        positions(pairKey: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        revokeAllowances(revokeActions: ISwapAdapter.RevokeActionStruct[], overrides?: CallOverrides): Promise<void>;
        runSwapsAndTransferMany(parameters: IDCAFeeManager.RunSwapsAndTransferManyParamsStruct, overrides?: CallOverrides): Promise<void>;
        terminatePositions(hub: PromiseOrValue<string>, positionIds: PromiseOrValue<BigNumberish>[], recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        withdrawFromBalance(amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        withdrawFromPlatformBalance(hub: PromiseOrValue<string>, amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        withdrawFromPositions(hub: PromiseOrValue<string>, positionSets: IDCAHubPositionHandler.PositionSetStruct[], recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    };
    filters: {};
    estimateGas: {
        MAX_TOKEN_TOTAL_SHARE(overrides?: CallOverrides): Promise<BigNumber>;
        SWAP_INTERVAL(overrides?: CallOverrides): Promise<BigNumber>;
        availableBalances(hub: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<BigNumber>;
        fillPositions(hub: PromiseOrValue<string>, amounts: IDCAFeeManager.AmountToFillStruct[], distribution: IDCAFeeManager.TargetTokenShareStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        positions(pairKey: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        revokeAllowances(revokeActions: ISwapAdapter.RevokeActionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        runSwapsAndTransferMany(parameters: IDCAFeeManager.RunSwapsAndTransferManyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        terminatePositions(hub: PromiseOrValue<string>, positionIds: PromiseOrValue<BigNumberish>[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawFromBalance(amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawFromPlatformBalance(hub: PromiseOrValue<string>, amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        withdrawFromPositions(hub: PromiseOrValue<string>, positionSets: IDCAHubPositionHandler.PositionSetStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        MAX_TOKEN_TOTAL_SHARE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        SWAP_INTERVAL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        availableBalances(hub: PromiseOrValue<string>, tokens: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
        fillPositions(hub: PromiseOrValue<string>, amounts: IDCAFeeManager.AmountToFillStruct[], distribution: IDCAFeeManager.TargetTokenShareStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        positions(pairKey: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revokeAllowances(revokeActions: ISwapAdapter.RevokeActionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        runSwapsAndTransferMany(parameters: IDCAFeeManager.RunSwapsAndTransferManyParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        terminatePositions(hub: PromiseOrValue<string>, positionIds: PromiseOrValue<BigNumberish>[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawFromBalance(amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawFromPlatformBalance(hub: PromiseOrValue<string>, amountToWithdraw: IDCAHub.AmountOfTokenStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        withdrawFromPositions(hub: PromiseOrValue<string>, positionSets: IDCAHubPositionHandler.PositionSetStruct[], recipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=IDCAFeeManager.d.ts.map