@merkl/contracts 1.2.34 → 1.2.35

package/dist/src/DefiEdgeAlgebraFactory.d.ts

@@ -0,0 +1,739 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export declare namespace IStrategyBase {
+    type TickStruct = {
+        tickLower: PromiseOrValue<BigNumberish>;
+        tickUpper: PromiseOrValue<BigNumberish>;
+    };
+    type TickStructOutput = [number, number] & {
+        tickLower: number;
+        tickUpper: number;
+    };
+}
+export declare namespace IStrategyFactory {
+    type CreateStrategyParamsStruct = {
+        operator: PromiseOrValue<string>;
+        feeTo: PromiseOrValue<string>;
+        managementFeeRate: PromiseOrValue<BigNumberish>;
+        performanceFeeRate: PromiseOrValue<BigNumberish>;
+        limit: PromiseOrValue<BigNumberish>;
+        pool: PromiseOrValue<string>;
+        usdAsBase: [PromiseOrValue<boolean>, PromiseOrValue<boolean>];
+        ticks: IStrategyBase.TickStruct[];
+    };
+    type CreateStrategyParamsStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        string,
+        [
+            boolean,
+            boolean
+        ],
+        IStrategyBase.TickStructOutput[]
+    ] & {
+        operator: string;
+        feeTo: string;
+        managementFeeRate: BigNumber;
+        performanceFeeRate: BigNumber;
+        limit: BigNumber;
+        pool: string;
+        usdAsBase: [boolean, boolean];
+        ticks: IStrategyBase.TickStructOutput[];
+    };
+}
+export interface DefiEdgeAlgebraFactoryInterface extends utils.Interface {
+    functions: {
+        "MAX_DECIMAL()": FunctionFragment;
+        "MAX_PROTOCOL_PERFORMANCE_FEES_RATE()": FunctionFragment;
+        "acceptGovernance()": FunctionFragment;
+        "algebraFactory()": FunctionFragment;
+        "allowedDeviation(address)": FunctionFragment;
+        "allowedSlippage(address)": FunctionFragment;
+        "allowedSwapDeviation(address)": FunctionFragment;
+        "chainlinkRegistry()": FunctionFragment;
+        "changeAllowedDeviation(address,uint256)": FunctionFragment;
+        "changeAllowedSlippage(address,uint256)": FunctionFragment;
+        "changeAllowedSwapDeviation(address,uint256)": FunctionFragment;
+        "changeDefaultValues(uint256,uint256,uint256)": FunctionFragment;
+        "changeFeeForStrategyCreation(uint256)": FunctionFragment;
+        "changeFeeTo(address)": FunctionFragment;
+        "changeGovernance(address)": FunctionFragment;
+        "changeMaxManagerPerformanceFeeRate(uint256)": FunctionFragment;
+        "changeProtocolFeeRate(uint256)": FunctionFragment;
+        "changeProtocolPerformanceFeeRate(address,address,uint256)": FunctionFragment;
+        "changeSwapProxy(address)": FunctionFragment;
+        "claimFees(address)": FunctionFragment;
+        "createStrategy((address,address,uint256,uint256,uint256,address,bool[2],(int24,int24)[]))": FunctionFragment;
+        "defaultAllowedDeviation()": FunctionFragment;
+        "defaultAllowedSlippage()": FunctionFragment;
+        "defaultAllowedSwapDeviation()": FunctionFragment;
+        "defaultProtocolPerformanceFeeRate()": FunctionFragment;
+        "denied(address)": FunctionFragment;
+        "deny(address,bool)": FunctionFragment;
+        "deployerProxy()": FunctionFragment;
+        "feeTo()": FunctionFragment;
+        "freezeEmergency()": FunctionFragment;
+        "freezeEmergencyFunctions()": FunctionFragment;
+        "getHeartBeat(address,address)": FunctionFragment;
+        "getProtocolPerformanceFeeRate(address,address)": FunctionFragment;
+        "governance()": FunctionFragment;
+        "isValidStrategy(address)": FunctionFragment;
+        "maximumManagerPerformanceFeeRate()": FunctionFragment;
+        "pendingGovernance()": FunctionFragment;
+        "protocolFeeRate()": FunctionFragment;
+        "protocolPerformanceFeeRateByPool(address)": FunctionFragment;
+        "protocolPerformanceFeeRateByStrategy(address)": FunctionFragment;
+        "setMinHeartbeat(address,address,uint256)": FunctionFragment;
+        "strategyByIndex(uint256)": FunctionFragment;
+        "strategyByManager(address)": FunctionFragment;
+        "strategyCreationFee()": FunctionFragment;
+        "swapProxy()": FunctionFragment;
+        "totalIndex()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "MAX_DECIMAL" | "MAX_PROTOCOL_PERFORMANCE_FEES_RATE" | "acceptGovernance" | "algebraFactory" | "allowedDeviation" | "allowedSlippage" | "allowedSwapDeviation" | "chainlinkRegistry" | "changeAllowedDeviation" | "changeAllowedSlippage" | "changeAllowedSwapDeviation" | "changeDefaultValues" | "changeFeeForStrategyCreation" | "changeFeeTo" | "changeGovernance" | "changeMaxManagerPerformanceFeeRate" | "changeProtocolFeeRate" | "changeProtocolPerformanceFeeRate" | "changeSwapProxy" | "claimFees" | "createStrategy" | "defaultAllowedDeviation" | "defaultAllowedSlippage" | "defaultAllowedSwapDeviation" | "defaultProtocolPerformanceFeeRate" | "denied" | "deny" | "deployerProxy" | "feeTo" | "freezeEmergency" | "freezeEmergencyFunctions" | "getHeartBeat" | "getProtocolPerformanceFeeRate" | "governance" | "isValidStrategy" | "maximumManagerPerformanceFeeRate" | "pendingGovernance" | "protocolFeeRate" | "protocolPerformanceFeeRateByPool" | "protocolPerformanceFeeRateByStrategy" | "setMinHeartbeat" | "strategyByIndex" | "strategyByManager" | "strategyCreationFee" | "swapProxy" | "totalIndex"): FunctionFragment;
+    encodeFunctionData(functionFragment: "MAX_DECIMAL", values?: undefined): string;
+    encodeFunctionData(functionFragment: "MAX_PROTOCOL_PERFORMANCE_FEES_RATE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "acceptGovernance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "algebraFactory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowedDeviation", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "allowedSlippage", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "allowedSwapDeviation", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "chainlinkRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "changeAllowedDeviation", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeAllowedSlippage", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeAllowedSwapDeviation", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeDefaultValues", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "changeFeeForStrategyCreation", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeFeeTo", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "changeGovernance", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "changeMaxManagerPerformanceFeeRate", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeProtocolFeeRate", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "changeProtocolPerformanceFeeRate", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "changeSwapProxy", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "claimFees", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "createStrategy", values: [IStrategyFactory.CreateStrategyParamsStruct]): string;
+    encodeFunctionData(functionFragment: "defaultAllowedDeviation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "defaultAllowedSlippage", values?: undefined): string;
+    encodeFunctionData(functionFragment: "defaultAllowedSwapDeviation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "defaultProtocolPerformanceFeeRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "denied", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "deny", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "deployerProxy", values?: undefined): string;
+    encodeFunctionData(functionFragment: "feeTo", values?: undefined): string;
+    encodeFunctionData(functionFragment: "freezeEmergency", values?: undefined): string;
+    encodeFunctionData(functionFragment: "freezeEmergencyFunctions", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getHeartBeat", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "getProtocolPerformanceFeeRate", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "governance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isValidStrategy", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "maximumManagerPerformanceFeeRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingGovernance", values?: undefined): string;
+    encodeFunctionData(functionFragment: "protocolFeeRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "protocolPerformanceFeeRateByPool", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "protocolPerformanceFeeRateByStrategy", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setMinHeartbeat", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "strategyByIndex", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "strategyByManager", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "strategyCreationFee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "swapProxy", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalIndex", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "MAX_DECIMAL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "MAX_PROTOCOL_PERFORMANCE_FEES_RATE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "acceptGovernance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "algebraFactory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedSlippage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedSwapDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "chainlinkRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAllowedDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAllowedSlippage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeAllowedSwapDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeDefaultValues", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeFeeForStrategyCreation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeFeeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeGovernance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeMaxManagerPerformanceFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeProtocolFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeProtocolPerformanceFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "changeSwapProxy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createStrategy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "defaultAllowedDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "defaultAllowedSlippage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "defaultAllowedSwapDeviation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "defaultProtocolPerformanceFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "denied", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deny", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deployerProxy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "feeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "freezeEmergency", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "freezeEmergencyFunctions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getHeartBeat", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getProtocolPerformanceFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isValidStrategy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maximumManagerPerformanceFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingGovernance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protocolFeeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protocolPerformanceFeeRateByPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "protocolPerformanceFeeRateByStrategy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setMinHeartbeat", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "strategyByIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "strategyByManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "strategyCreationFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapProxy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalIndex", data: BytesLike): Result;
+    events: {
+        "ChangeAllowedDeviation(address,uint256)": EventFragment;
+        "ChangeAllowedSlippage(address,uint256)": EventFragment;
+        "ChangeAllowedSwapDeviation(address,uint256)": EventFragment;
+        "ChangeDefaultMaxManagerPerformanceFee(uint256)": EventFragment;
+        "ChangeProtocolFee(uint256)": EventFragment;
+        "ChangeProtocolPerformanceFee(address,uint256)": EventFragment;
+        "ChangeStrategyCreationFee(uint256)": EventFragment;
+        "ChangeSwapProxy(address)": EventFragment;
+        "ClaimFees(address,uint256)": EventFragment;
+        "EmergencyFrozen()": EventFragment;
+        "NewStrategy(address,address)": EventFragment;
+        "StrategyStatusChanged(bool)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ChangeAllowedDeviation"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeAllowedSlippage"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeAllowedSwapDeviation"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeDefaultMaxManagerPerformanceFee"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeProtocolFee"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeProtocolPerformanceFee"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeStrategyCreationFee"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ChangeSwapProxy"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ClaimFees"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "EmergencyFrozen"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewStrategy"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StrategyStatusChanged"): EventFragment;
+}
+export interface ChangeAllowedDeviationEventObject {
+    pool: string;
+    value: BigNumber;
+}
+export type ChangeAllowedDeviationEvent = TypedEvent<[
+    string,
+    BigNumber
+], ChangeAllowedDeviationEventObject>;
+export type ChangeAllowedDeviationEventFilter = TypedEventFilter<ChangeAllowedDeviationEvent>;
+export interface ChangeAllowedSlippageEventObject {
+    pool: string;
+    value: BigNumber;
+}
+export type ChangeAllowedSlippageEvent = TypedEvent<[
+    string,
+    BigNumber
+], ChangeAllowedSlippageEventObject>;
+export type ChangeAllowedSlippageEventFilter = TypedEventFilter<ChangeAllowedSlippageEvent>;
+export interface ChangeAllowedSwapDeviationEventObject {
+    pool: string;
+    value: BigNumber;
+}
+export type ChangeAllowedSwapDeviationEvent = TypedEvent<[
+    string,
+    BigNumber
+], ChangeAllowedSwapDeviationEventObject>;
+export type ChangeAllowedSwapDeviationEventFilter = TypedEventFilter<ChangeAllowedSwapDeviationEvent>;
+export interface ChangeDefaultMaxManagerPerformanceFeeEventObject {
+    _feeRate: BigNumber;
+}
+export type ChangeDefaultMaxManagerPerformanceFeeEvent = TypedEvent<[
+    BigNumber
+], ChangeDefaultMaxManagerPerformanceFeeEventObject>;
+export type ChangeDefaultMaxManagerPerformanceFeeEventFilter = TypedEventFilter<ChangeDefaultMaxManagerPerformanceFeeEvent>;
+export interface ChangeProtocolFeeEventObject {
+    fee: BigNumber;
+}
+export type ChangeProtocolFeeEvent = TypedEvent<[
+    BigNumber
+], ChangeProtocolFeeEventObject>;
+export type ChangeProtocolFeeEventFilter = TypedEventFilter<ChangeProtocolFeeEvent>;
+export interface ChangeProtocolPerformanceFeeEventObject {
+    strategyOrPool: string;
+    _feeRate: BigNumber;
+}
+export type ChangeProtocolPerformanceFeeEvent = TypedEvent<[
+    string,
+    BigNumber
+], ChangeProtocolPerformanceFeeEventObject>;
+export type ChangeProtocolPerformanceFeeEventFilter = TypedEventFilter<ChangeProtocolPerformanceFeeEvent>;
+export interface ChangeStrategyCreationFeeEventObject {
+    amount: BigNumber;
+}
+export type ChangeStrategyCreationFeeEvent = TypedEvent<[
+    BigNumber
+], ChangeStrategyCreationFeeEventObject>;
+export type ChangeStrategyCreationFeeEventFilter = TypedEventFilter<ChangeStrategyCreationFeeEvent>;
+export interface ChangeSwapProxyEventObject {
+    newSwapProxy: string;
+}
+export type ChangeSwapProxyEvent = TypedEvent<[
+    string
+], ChangeSwapProxyEventObject>;
+export type ChangeSwapProxyEventFilter = TypedEventFilter<ChangeSwapProxyEvent>;
+export interface ClaimFeesEventObject {
+    to: string;
+    amount: BigNumber;
+}
+export type ClaimFeesEvent = TypedEvent<[
+    string,
+    BigNumber
+], ClaimFeesEventObject>;
+export type ClaimFeesEventFilter = TypedEventFilter<ClaimFeesEvent>;
+export interface EmergencyFrozenEventObject {
+}
+export type EmergencyFrozenEvent = TypedEvent<[], EmergencyFrozenEventObject>;
+export type EmergencyFrozenEventFilter = TypedEventFilter<EmergencyFrozenEvent>;
+export interface NewStrategyEventObject {
+    strategy: string;
+    creater: string;
+}
+export type NewStrategyEvent = TypedEvent<[
+    string,
+    string
+], NewStrategyEventObject>;
+export type NewStrategyEventFilter = TypedEventFilter<NewStrategyEvent>;
+export interface StrategyStatusChangedEventObject {
+    status: boolean;
+}
+export type StrategyStatusChangedEvent = TypedEvent<[
+    boolean
+], StrategyStatusChangedEventObject>;
+export type StrategyStatusChangedEventFilter = TypedEventFilter<StrategyStatusChangedEvent>;
+export interface DefiEdgeAlgebraFactory extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: DefiEdgeAlgebraFactoryInterface;
+    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_DECIMAL(overrides?: CallOverrides): Promise<[BigNumber]>;
+        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<[BigNumber]>;
+        acceptGovernance(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        algebraFactory(overrides?: CallOverrides): Promise<[string]>;
+        allowedDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        chainlinkRegistry(overrides?: CallOverrides): Promise<[string]>;
+        changeAllowedDeviation(_pool: PromiseOrValue<string>, _allowedDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedDeviation: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeMaxManagerPerformanceFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createStrategy(params: IStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        defaultAllowedDeviation(overrides?: CallOverrides): Promise<[BigNumber]>;
+        defaultAllowedSlippage(overrides?: CallOverrides): Promise<[BigNumber]>;
+        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<[BigNumber]>;
+        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
+        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        deployerProxy(overrides?: CallOverrides): Promise<[string]>;
+        feeTo(overrides?: CallOverrides): Promise<[string]>;
+        freezeEmergency(overrides?: CallOverrides): Promise<[boolean]>;
+        freezeEmergencyFunctions(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber] & {
+            _feeRate: BigNumber;
+        }>;
+        governance(overrides?: CallOverrides): Promise<[string]>;
+        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        maximumManagerPerformanceFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
+        pendingGovernance(overrides?: CallOverrides): Promise<[string]>;
+        protocolFeeRate(overrides?: CallOverrides): Promise<[BigNumber]>;
+        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
+        strategyCreationFee(overrides?: CallOverrides): Promise<[BigNumber]>;
+        swapProxy(overrides?: CallOverrides): Promise<[string]>;
+        totalIndex(overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
+    MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
+    acceptGovernance(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    algebraFactory(overrides?: CallOverrides): Promise<string>;
+    allowedDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    chainlinkRegistry(overrides?: CallOverrides): Promise<string>;
+    changeAllowedDeviation(_pool: PromiseOrValue<string>, _allowedDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedDeviation: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeMaxManagerPerformanceFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createStrategy(params: IStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    defaultAllowedDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+    defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
+    defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+    defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+    denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    deployerProxy(overrides?: CallOverrides): Promise<string>;
+    feeTo(overrides?: CallOverrides): Promise<string>;
+    freezeEmergency(overrides?: CallOverrides): Promise<boolean>;
+    freezeEmergencyFunctions(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    governance(overrides?: CallOverrides): Promise<string>;
+    isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    maximumManagerPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+    pendingGovernance(overrides?: CallOverrides): Promise<string>;
+    protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+    protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+    strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
+    swapProxy(overrides?: CallOverrides): Promise<string>;
+    totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
+        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
+        acceptGovernance(overrides?: CallOverrides): Promise<void>;
+        algebraFactory(overrides?: CallOverrides): Promise<string>;
+        allowedDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        chainlinkRegistry(overrides?: CallOverrides): Promise<string>;
+        changeAllowedDeviation(_pool: PromiseOrValue<string>, _allowedDeviation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedDeviation: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        changeGovernance(_governance: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        changeMaxManagerPerformanceFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        claimFees(_to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        createStrategy(params: IStrategyFactory.CreateStrategyParamsStruct, overrides?: CallOverrides): Promise<void>;
+        defaultAllowedDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        deployerProxy(overrides?: CallOverrides): Promise<string>;
+        feeTo(overrides?: CallOverrides): Promise<string>;
+        freezeEmergency(overrides?: CallOverrides): Promise<boolean>;
+        freezeEmergencyFunctions(overrides?: CallOverrides): Promise<void>;
+        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        governance(overrides?: CallOverrides): Promise<string>;
+        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        maximumManagerPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingGovernance(overrides?: CallOverrides): Promise<string>;
+        protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
+        swapProxy(overrides?: CallOverrides): Promise<string>;
+        totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "ChangeAllowedDeviation(address,uint256)"(pool?: null, value?: null): ChangeAllowedDeviationEventFilter;
+        ChangeAllowedDeviation(pool?: null, value?: null): ChangeAllowedDeviationEventFilter;
+        "ChangeAllowedSlippage(address,uint256)"(pool?: null, value?: null): ChangeAllowedSlippageEventFilter;
+        ChangeAllowedSlippage(pool?: null, value?: null): ChangeAllowedSlippageEventFilter;
+        "ChangeAllowedSwapDeviation(address,uint256)"(pool?: null, value?: null): ChangeAllowedSwapDeviationEventFilter;
+        ChangeAllowedSwapDeviation(pool?: null, value?: null): ChangeAllowedSwapDeviationEventFilter;
+        "ChangeDefaultMaxManagerPerformanceFee(uint256)"(_feeRate?: null): ChangeDefaultMaxManagerPerformanceFeeEventFilter;
+        ChangeDefaultMaxManagerPerformanceFee(_feeRate?: null): ChangeDefaultMaxManagerPerformanceFeeEventFilter;
+        "ChangeProtocolFee(uint256)"(fee?: null): ChangeProtocolFeeEventFilter;
+        ChangeProtocolFee(fee?: null): ChangeProtocolFeeEventFilter;
+        "ChangeProtocolPerformanceFee(address,uint256)"(strategyOrPool?: null, _feeRate?: null): ChangeProtocolPerformanceFeeEventFilter;
+        ChangeProtocolPerformanceFee(strategyOrPool?: null, _feeRate?: null): ChangeProtocolPerformanceFeeEventFilter;
+        "ChangeStrategyCreationFee(uint256)"(amount?: null): ChangeStrategyCreationFeeEventFilter;
+        ChangeStrategyCreationFee(amount?: null): ChangeStrategyCreationFeeEventFilter;
+        "ChangeSwapProxy(address)"(newSwapProxy?: null): ChangeSwapProxyEventFilter;
+        ChangeSwapProxy(newSwapProxy?: null): ChangeSwapProxyEventFilter;
+        "ClaimFees(address,uint256)"(to?: null, amount?: null): ClaimFeesEventFilter;
+        ClaimFees(to?: null, amount?: null): ClaimFeesEventFilter;
+        "EmergencyFrozen()"(): EmergencyFrozenEventFilter;
+        EmergencyFrozen(): EmergencyFrozenEventFilter;
+        "NewStrategy(address,address)"(strategy?: PromiseOrValue<string> | null, creater?: PromiseOrValue<string> | null): NewStrategyEventFilter;
+        NewStrategy(strategy?: PromiseOrValue<string> | null, creater?: PromiseOrValue<string> | null): NewStrategyEventFilter;
+        "StrategyStatusChanged(bool)"(status?: null): StrategyStatusChangedEventFilter;
+        StrategyStatusChanged(status?: null): StrategyStatusChangedEventFilter;
+    };
+    estimateGas: {
+        MAX_DECIMAL(overrides?: CallOverrides): Promise<BigNumber>;
+        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<BigNumber>;
+        acceptGovernance(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        algebraFactory(overrides?: CallOverrides): Promise<BigNumber>;
+        allowedDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        chainlinkRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        changeAllowedDeviation(_pool: PromiseOrValue<string>, _allowedDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedDeviation: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeMaxManagerPerformanceFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createStrategy(params: IStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        defaultAllowedDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultAllowedSlippage(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<BigNumber>;
+        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        deployerProxy(overrides?: CallOverrides): Promise<BigNumber>;
+        feeTo(overrides?: CallOverrides): Promise<BigNumber>;
+        freezeEmergency(overrides?: CallOverrides): Promise<BigNumber>;
+        freezeEmergencyFunctions(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        governance(overrides?: CallOverrides): Promise<BigNumber>;
+        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        maximumManagerPerformanceFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingGovernance(overrides?: CallOverrides): Promise<BigNumber>;
+        protocolFeeRate(overrides?: CallOverrides): Promise<BigNumber>;
+        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        strategyCreationFee(overrides?: CallOverrides): Promise<BigNumber>;
+        swapProxy(overrides?: CallOverrides): Promise<BigNumber>;
+        totalIndex(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        MAX_DECIMAL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        MAX_PROTOCOL_PERFORMANCE_FEES_RATE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        acceptGovernance(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        algebraFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allowedDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allowedSlippage(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allowedSwapDeviation(_pool: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        chainlinkRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        changeAllowedDeviation(_pool: PromiseOrValue<string>, _allowedDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeAllowedSlippage(_pool: PromiseOrValue<string>, _allowedSlippage: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeAllowedSwapDeviation(_pool: PromiseOrValue<string>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeDefaultValues(_allowedSlippage: PromiseOrValue<BigNumberish>, _allowedDeviation: PromiseOrValue<BigNumberish>, _allowedSwapDeviation: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeFeeForStrategyCreation(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeFeeTo(_feeTo: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeGovernance(_governance: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeMaxManagerPerformanceFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeProtocolFeeRate(_fee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, _feeRate: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        changeSwapProxy(_swapProxy: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claimFees(_to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createStrategy(params: IStrategyFactory.CreateStrategyParamsStruct, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        defaultAllowedDeviation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        defaultAllowedSlippage(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        defaultAllowedSwapDeviation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        defaultProtocolPerformanceFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        denied(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        deny(_strategy: PromiseOrValue<string>, _status: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        deployerProxy(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        feeTo(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        freezeEmergency(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        freezeEmergencyFunctions(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getHeartBeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getProtocolPerformanceFeeRate(pool: PromiseOrValue<string>, strategy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        governance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isValidStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        maximumManagerPerformanceFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingGovernance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        protocolFeeRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        protocolPerformanceFeeRateByPool(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        protocolPerformanceFeeRateByStrategy(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setMinHeartbeat(_base: PromiseOrValue<string>, _quote: PromiseOrValue<string>, _period: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        strategyByIndex(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        strategyByManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        strategyCreationFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swapProxy(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalIndex(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}