@merkl/contracts 1.2.34 → 1.2.35

package/dist/src/DefiEdgeAlgebraStrategy.d.ts

@@ -0,0 +1,727 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 DefiEdgeStrategy {
+    type PartialTickStruct = {
+        index: PromiseOrValue<BigNumberish>;
+        burn: PromiseOrValue<boolean>;
+        amount0: PromiseOrValue<BigNumberish>;
+        amount1: PromiseOrValue<BigNumberish>;
+    };
+    type PartialTickStructOutput = [
+        BigNumber,
+        boolean,
+        BigNumber,
+        BigNumber
+    ] & {
+        index: BigNumber;
+        burn: boolean;
+        amount0: BigNumber;
+        amount1: BigNumber;
+    };
+    type NewTickStruct = {
+        tickLower: PromiseOrValue<BigNumberish>;
+        tickUpper: PromiseOrValue<BigNumberish>;
+        amount0: PromiseOrValue<BigNumberish>;
+        amount1: PromiseOrValue<BigNumberish>;
+    };
+    type NewTickStructOutput = [number, number, BigNumber, BigNumber] & {
+        tickLower: number;
+        tickUpper: number;
+        amount0: BigNumber;
+        amount1: BigNumber;
+    };
+}
+export interface DefiEdgeAlgebraStrategyInterface extends utils.Interface {
+    functions: {
+        "FEE_PRECISION()": FunctionFragment;
+        "MAX_TICK_LENGTH()": FunctionFragment;
+        "MINIMUM_LIQUIDITY()": FunctionFragment;
+        "accManagementFeeShares()": FunctionFragment;
+        "accPerformanceFeeShares()": FunctionFragment;
+        "accProtocolPerformanceFeeShares()": FunctionFragment;
+        "algebraMintCallback(uint256,uint256,bytes)": FunctionFragment;
+        "allowance(address,address)": FunctionFragment;
+        "approve(address,uint256)": FunctionFragment;
+        "balanceOf(address)": FunctionFragment;
+        "burn(uint256,uint256,uint256)": FunctionFragment;
+        "burnLiquiditySingle(uint256)": FunctionFragment;
+        "claimFee()": FunctionFragment;
+        "decimals()": FunctionFragment;
+        "decreaseAllowance(address,uint256)": FunctionFragment;
+        "emergencyWithdraw(address,address,uint256,(int24,int24,uint256,uint256)[])": FunctionFragment;
+        "factory()": FunctionFragment;
+        "getAUMWithFees(bool)": FunctionFragment;
+        "getTicks()": FunctionFragment;
+        "increaseAllowance(address,uint256)": FunctionFragment;
+        "manager()": FunctionFragment;
+        "mint(uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
+        "name()": FunctionFragment;
+        "onHold()": FunctionFragment;
+        "pool()": FunctionFragment;
+        "rebalance(bool,uint256,bool,bytes,(uint256,bool,uint256,uint256)[],(int24,int24,uint256,uint256)[],bool)": FunctionFragment;
+        "reserve0()": FunctionFragment;
+        "reserve1()": FunctionFragment;
+        "skim(address)": FunctionFragment;
+        "swap(bool,uint256,bool,bytes)": FunctionFragment;
+        "symbol()": FunctionFragment;
+        "sync()": FunctionFragment;
+        "ticks(uint256)": FunctionFragment;
+        "totalSupply()": FunctionFragment;
+        "transfer(address,uint256)": FunctionFragment;
+        "transferFrom(address,address,uint256)": FunctionFragment;
+        "usdAsBase(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "FEE_PRECISION" | "MAX_TICK_LENGTH" | "MINIMUM_LIQUIDITY" | "accManagementFeeShares" | "accPerformanceFeeShares" | "accProtocolPerformanceFeeShares" | "algebraMintCallback" | "allowance" | "approve" | "balanceOf" | "burn" | "burnLiquiditySingle" | "claimFee" | "decimals" | "decreaseAllowance" | "emergencyWithdraw" | "factory" | "getAUMWithFees" | "getTicks" | "increaseAllowance" | "manager" | "mint" | "name" | "onHold" | "pool" | "rebalance" | "reserve0" | "reserve1" | "skim" | "swap" | "symbol" | "sync" | "ticks" | "totalSupply" | "transfer" | "transferFrom" | "usdAsBase"): FunctionFragment;
+    encodeFunctionData(functionFragment: "FEE_PRECISION", values?: undefined): string;
+    encodeFunctionData(functionFragment: "MAX_TICK_LENGTH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "MINIMUM_LIQUIDITY", values?: undefined): string;
+    encodeFunctionData(functionFragment: "accManagementFeeShares", values?: undefined): string;
+    encodeFunctionData(functionFragment: "accPerformanceFeeShares", values?: undefined): string;
+    encodeFunctionData(functionFragment: "accProtocolPerformanceFeeShares", values?: undefined): string;
+    encodeFunctionData(functionFragment: "algebraMintCallback", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "allowance", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "burn", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "burnLiquiditySingle", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "claimFee", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "emergencyWithdraw", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        DefiEdgeStrategy.NewTickStruct[]
+    ]): string;
+    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAUMWithFees", values: [PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "getTicks", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "manager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "mint", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "onHold", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pool", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rebalance", values: [
+        PromiseOrValue<boolean>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<boolean>,
+        PromiseOrValue<BytesLike>,
+        DefiEdgeStrategy.PartialTickStruct[],
+        DefiEdgeStrategy.NewTickStruct[],
+        PromiseOrValue<boolean>
+    ]): string;
+    encodeFunctionData(functionFragment: "reserve0", values?: undefined): string;
+    encodeFunctionData(functionFragment: "reserve1", values?: undefined): string;
+    encodeFunctionData(functionFragment: "skim", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "swap", values: [
+        PromiseOrValue<boolean>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<boolean>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sync", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ticks", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "usdAsBase", values: [PromiseOrValue<BigNumberish>]): string;
+    decodeFunctionResult(functionFragment: "FEE_PRECISION", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "MAX_TICK_LENGTH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "MINIMUM_LIQUIDITY", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accManagementFeeShares", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accPerformanceFeeShares", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "accProtocolPerformanceFeeShares", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "algebraMintCallback", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnLiquiditySingle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAUMWithFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTicks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "manager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onHold", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rebalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reserve0", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reserve1", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "skim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sync", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ticks", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "usdAsBase", data: BytesLike): Result;
+    events: {
+        "Approval(address,address,uint256)": EventFragment;
+        "Burn(address,uint256,uint256,uint256)": EventFragment;
+        "ClaimFee(uint256,uint256)": EventFragment;
+        "FeesClaim(address,uint256,uint256)": EventFragment;
+        "Hold()": EventFragment;
+        "Mint(address,uint256,uint256,uint256)": EventFragment;
+        "PartialRebalance(tuple[])": EventFragment;
+        "Rebalance(tuple[])": EventFragment;
+        "Swap(uint256,uint256,bool)": EventFragment;
+        "Sync(uint256,uint256)": EventFragment;
+        "Transfer(address,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Burn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ClaimFee"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "FeesClaim"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Hold"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Mint"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PartialRebalance"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Rebalance"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Swap"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Sync"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+}
+export interface ApprovalEventObject {
+    owner: string;
+    spender: string;
+    value: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], ApprovalEventObject>;
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+export interface BurnEventObject {
+    user: string;
+    share: BigNumber;
+    amount0: BigNumber;
+    amount1: BigNumber;
+}
+export type BurnEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], BurnEventObject>;
+export type BurnEventFilter = TypedEventFilter<BurnEvent>;
+export interface ClaimFeeEventObject {
+    managerFee: BigNumber;
+    protocolFee: BigNumber;
+}
+export type ClaimFeeEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], ClaimFeeEventObject>;
+export type ClaimFeeEventFilter = TypedEventFilter<ClaimFeeEvent>;
+export interface FeesClaimEventObject {
+    strategy: string;
+    amount0: BigNumber;
+    amount1: BigNumber;
+}
+export type FeesClaimEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], FeesClaimEventObject>;
+export type FeesClaimEventFilter = TypedEventFilter<FeesClaimEvent>;
+export interface HoldEventObject {
+}
+export type HoldEvent = TypedEvent<[], HoldEventObject>;
+export type HoldEventFilter = TypedEventFilter<HoldEvent>;
+export interface MintEventObject {
+    user: string;
+    share: BigNumber;
+    amount0: BigNumber;
+    amount1: BigNumber;
+}
+export type MintEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], MintEventObject>;
+export type MintEventFilter = TypedEventFilter<MintEvent>;
+export interface PartialRebalanceEventObject {
+    ticks: DefiEdgeStrategy.PartialTickStructOutput[];
+}
+export type PartialRebalanceEvent = TypedEvent<[
+    DefiEdgeStrategy.PartialTickStructOutput[]
+], PartialRebalanceEventObject>;
+export type PartialRebalanceEventFilter = TypedEventFilter<PartialRebalanceEvent>;
+export interface RebalanceEventObject {
+    ticks: DefiEdgeStrategy.NewTickStructOutput[];
+}
+export type RebalanceEvent = TypedEvent<[
+    DefiEdgeStrategy.NewTickStructOutput[]
+], RebalanceEventObject>;
+export type RebalanceEventFilter = TypedEventFilter<RebalanceEvent>;
+export interface SwapEventObject {
+    amountIn: BigNumber;
+    amountOut: BigNumber;
+    _zeroForOne: boolean;
+}
+export type SwapEvent = TypedEvent<[
+    BigNumber,
+    BigNumber,
+    boolean
+], SwapEventObject>;
+export type SwapEventFilter = TypedEventFilter<SwapEvent>;
+export interface SyncEventObject {
+    reserve0: BigNumber;
+    reserve1: BigNumber;
+}
+export type SyncEvent = TypedEvent<[BigNumber, BigNumber], SyncEventObject>;
+export type SyncEventFilter = TypedEventFilter<SyncEvent>;
+export interface TransferEventObject {
+    from: string;
+    to: string;
+    value: BigNumber;
+}
+export type TransferEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], TransferEventObject>;
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+export interface DefiEdgeAlgebraStrategy extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: DefiEdgeAlgebraStrategyInterface;
+    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: {
+        FEE_PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;
+        MAX_TICK_LENGTH(overrides?: CallOverrides): Promise<[BigNumber]>;
+        MINIMUM_LIQUIDITY(overrides?: CallOverrides): Promise<[BigNumber]>;
+        accManagementFeeShares(overrides?: CallOverrides): Promise<[BigNumber]>;
+        accPerformanceFeeShares(overrides?: CallOverrides): Promise<[BigNumber]>;
+        accProtocolPerformanceFeeShares(overrides?: CallOverrides): Promise<[BigNumber]>;
+        algebraMintCallback(amount0: PromiseOrValue<BigNumberish>, amount1: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        allowance(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        burn(_shares: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        burnLiquiditySingle(_tickIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claimFee(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        decimals(overrides?: CallOverrides): Promise<[number]>;
+        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        emergencyWithdraw(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _newTicks: DefiEdgeStrategy.NewTickStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        factory(overrides?: CallOverrides): Promise<[string]>;
+        getAUMWithFees(_includeFee: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        getTicks(overrides?: CallOverrides): Promise<[IStrategyBase.TickStructOutput[]]>;
+        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        manager(overrides?: CallOverrides): Promise<[string]>;
+        mint(_amount0: PromiseOrValue<BigNumberish>, _amount1: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, _minShare: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        name(overrides?: CallOverrides): Promise<[string]>;
+        onHold(overrides?: CallOverrides): Promise<[boolean]>;
+        pool(overrides?: CallOverrides): Promise<[string]>;
+        rebalance(_zeroToOne: PromiseOrValue<boolean>, _amountIn: PromiseOrValue<BigNumberish>, _isOneInchSwap: PromiseOrValue<boolean>, _swapData: PromiseOrValue<BytesLike>, _existingTicks: DefiEdgeStrategy.PartialTickStruct[], _newTicks: DefiEdgeStrategy.NewTickStruct[], _burnAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        reserve0(overrides?: CallOverrides): Promise<[BigNumber]>;
+        reserve1(overrides?: CallOverrides): Promise<[BigNumber]>;
+        skim(to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        swap(zeroToOne: PromiseOrValue<boolean>, amountIn: PromiseOrValue<BigNumberish>, isOneInchSwap: PromiseOrValue<boolean>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        symbol(overrides?: CallOverrides): Promise<[string]>;
+        sync(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        ticks(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[number, number] & {
+            tickLower: number;
+            tickUpper: number;
+        }>;
+        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        usdAsBase(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    FEE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+    MAX_TICK_LENGTH(overrides?: CallOverrides): Promise<BigNumber>;
+    MINIMUM_LIQUIDITY(overrides?: CallOverrides): Promise<BigNumber>;
+    accManagementFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+    accPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+    accProtocolPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+    algebraMintCallback(amount0: PromiseOrValue<BigNumberish>, amount1: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    allowance(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    burn(_shares: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    burnLiquiditySingle(_tickIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claimFee(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    decimals(overrides?: CallOverrides): Promise<number>;
+    decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    emergencyWithdraw(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _newTicks: DefiEdgeStrategy.NewTickStruct[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    factory(overrides?: CallOverrides): Promise<string>;
+    getAUMWithFees(_includeFee: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    getTicks(overrides?: CallOverrides): Promise<IStrategyBase.TickStructOutput[]>;
+    increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    manager(overrides?: CallOverrides): Promise<string>;
+    mint(_amount0: PromiseOrValue<BigNumberish>, _amount1: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, _minShare: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    name(overrides?: CallOverrides): Promise<string>;
+    onHold(overrides?: CallOverrides): Promise<boolean>;
+    pool(overrides?: CallOverrides): Promise<string>;
+    rebalance(_zeroToOne: PromiseOrValue<boolean>, _amountIn: PromiseOrValue<BigNumberish>, _isOneInchSwap: PromiseOrValue<boolean>, _swapData: PromiseOrValue<BytesLike>, _existingTicks: DefiEdgeStrategy.PartialTickStruct[], _newTicks: DefiEdgeStrategy.NewTickStruct[], _burnAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    reserve0(overrides?: CallOverrides): Promise<BigNumber>;
+    reserve1(overrides?: CallOverrides): Promise<BigNumber>;
+    skim(to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    swap(zeroToOne: PromiseOrValue<boolean>, amountIn: PromiseOrValue<BigNumberish>, isOneInchSwap: PromiseOrValue<boolean>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    symbol(overrides?: CallOverrides): Promise<string>;
+    sync(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    ticks(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[number, number] & {
+        tickLower: number;
+        tickUpper: number;
+    }>;
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+    transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    usdAsBase(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        FEE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+        MAX_TICK_LENGTH(overrides?: CallOverrides): Promise<BigNumber>;
+        MINIMUM_LIQUIDITY(overrides?: CallOverrides): Promise<BigNumber>;
+        accManagementFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        accPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        accProtocolPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        algebraMintCallback(amount0: PromiseOrValue<BigNumberish>, amount1: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        allowance(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        burn(_shares: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            collect0: BigNumber;
+            collect1: BigNumber;
+        }>;
+        burnLiquiditySingle(_tickIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amount0: BigNumber;
+            amount1: BigNumber;
+            fee0: BigNumber;
+            fee1: BigNumber;
+        }>;
+        claimFee(overrides?: CallOverrides): Promise<void>;
+        decimals(overrides?: CallOverrides): Promise<number>;
+        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        emergencyWithdraw(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _newTicks: DefiEdgeStrategy.NewTickStruct[], overrides?: CallOverrides): Promise<void>;
+        factory(overrides?: CallOverrides): Promise<string>;
+        getAUMWithFees(_includeFee: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amount0: BigNumber;
+            amount1: BigNumber;
+            totalFee0: BigNumber;
+            totalFee1: BigNumber;
+        }>;
+        getTicks(overrides?: CallOverrides): Promise<IStrategyBase.TickStructOutput[]>;
+        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        manager(overrides?: CallOverrides): Promise<string>;
+        mint(_amount0: PromiseOrValue<BigNumberish>, _amount1: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, _minShare: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amount0: BigNumber;
+            amount1: BigNumber;
+            share: BigNumber;
+        }>;
+        name(overrides?: CallOverrides): Promise<string>;
+        onHold(overrides?: CallOverrides): Promise<boolean>;
+        pool(overrides?: CallOverrides): Promise<string>;
+        rebalance(_zeroToOne: PromiseOrValue<boolean>, _amountIn: PromiseOrValue<BigNumberish>, _isOneInchSwap: PromiseOrValue<boolean>, _swapData: PromiseOrValue<BytesLike>, _existingTicks: DefiEdgeStrategy.PartialTickStruct[], _newTicks: DefiEdgeStrategy.NewTickStruct[], _burnAll: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        reserve0(overrides?: CallOverrides): Promise<BigNumber>;
+        reserve1(overrides?: CallOverrides): Promise<BigNumber>;
+        skim(to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        swap(zeroToOne: PromiseOrValue<boolean>, amountIn: PromiseOrValue<BigNumberish>, isOneInchSwap: PromiseOrValue<boolean>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        symbol(overrides?: CallOverrides): Promise<string>;
+        sync(overrides?: CallOverrides): Promise<void>;
+        ticks(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[number, number] & {
+            tickLower: number;
+            tickUpper: number;
+        }>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        usdAsBase(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {
+        "Approval(address,address,uint256)"(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
+        Approval(owner?: PromiseOrValue<string> | null, spender?: PromiseOrValue<string> | null, value?: null): ApprovalEventFilter;
+        "Burn(address,uint256,uint256,uint256)"(user?: PromiseOrValue<string> | null, share?: null, amount0?: null, amount1?: null): BurnEventFilter;
+        Burn(user?: PromiseOrValue<string> | null, share?: null, amount0?: null, amount1?: null): BurnEventFilter;
+        "ClaimFee(uint256,uint256)"(managerFee?: null, protocolFee?: null): ClaimFeeEventFilter;
+        ClaimFee(managerFee?: null, protocolFee?: null): ClaimFeeEventFilter;
+        "FeesClaim(address,uint256,uint256)"(strategy?: PromiseOrValue<string> | null, amount0?: null, amount1?: null): FeesClaimEventFilter;
+        FeesClaim(strategy?: PromiseOrValue<string> | null, amount0?: null, amount1?: null): FeesClaimEventFilter;
+        "Hold()"(): HoldEventFilter;
+        Hold(): HoldEventFilter;
+        "Mint(address,uint256,uint256,uint256)"(user?: PromiseOrValue<string> | null, share?: null, amount0?: null, amount1?: null): MintEventFilter;
+        Mint(user?: PromiseOrValue<string> | null, share?: null, amount0?: null, amount1?: null): MintEventFilter;
+        "PartialRebalance(tuple[])"(ticks?: null): PartialRebalanceEventFilter;
+        PartialRebalance(ticks?: null): PartialRebalanceEventFilter;
+        "Rebalance(tuple[])"(ticks?: null): RebalanceEventFilter;
+        Rebalance(ticks?: null): RebalanceEventFilter;
+        "Swap(uint256,uint256,bool)"(amountIn?: null, amountOut?: null, _zeroForOne?: null): SwapEventFilter;
+        Swap(amountIn?: null, amountOut?: null, _zeroForOne?: null): SwapEventFilter;
+        "Sync(uint256,uint256)"(reserve0?: null, reserve1?: null): SyncEventFilter;
+        Sync(reserve0?: null, reserve1?: null): SyncEventFilter;
+        "Transfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
+        Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, value?: null): TransferEventFilter;
+    };
+    estimateGas: {
+        FEE_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;
+        MAX_TICK_LENGTH(overrides?: CallOverrides): Promise<BigNumber>;
+        MINIMUM_LIQUIDITY(overrides?: CallOverrides): Promise<BigNumber>;
+        accManagementFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        accPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        accProtocolPerformanceFeeShares(overrides?: CallOverrides): Promise<BigNumber>;
+        algebraMintCallback(amount0: PromiseOrValue<BigNumberish>, amount1: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        allowance(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        burn(_shares: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        burnLiquiditySingle(_tickIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claimFee(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        decimals(overrides?: CallOverrides): Promise<BigNumber>;
+        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        emergencyWithdraw(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _newTicks: DefiEdgeStrategy.NewTickStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        factory(overrides?: CallOverrides): Promise<BigNumber>;
+        getAUMWithFees(_includeFee: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        getTicks(overrides?: CallOverrides): Promise<BigNumber>;
+        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        manager(overrides?: CallOverrides): Promise<BigNumber>;
+        mint(_amount0: PromiseOrValue<BigNumberish>, _amount1: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, _minShare: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        name(overrides?: CallOverrides): Promise<BigNumber>;
+        onHold(overrides?: CallOverrides): Promise<BigNumber>;
+        pool(overrides?: CallOverrides): Promise<BigNumber>;
+        rebalance(_zeroToOne: PromiseOrValue<boolean>, _amountIn: PromiseOrValue<BigNumberish>, _isOneInchSwap: PromiseOrValue<boolean>, _swapData: PromiseOrValue<BytesLike>, _existingTicks: DefiEdgeStrategy.PartialTickStruct[], _newTicks: DefiEdgeStrategy.NewTickStruct[], _burnAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        reserve0(overrides?: CallOverrides): Promise<BigNumber>;
+        reserve1(overrides?: CallOverrides): Promise<BigNumber>;
+        skim(to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        swap(zeroToOne: PromiseOrValue<boolean>, amountIn: PromiseOrValue<BigNumberish>, isOneInchSwap: PromiseOrValue<boolean>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        symbol(overrides?: CallOverrides): Promise<BigNumber>;
+        sync(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        ticks(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        usdAsBase(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        FEE_PRECISION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        MAX_TICK_LENGTH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        MINIMUM_LIQUIDITY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        accManagementFeeShares(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        accPerformanceFeeShares(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        accProtocolPerformanceFeeShares(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        algebraMintCallback(amount0: PromiseOrValue<BigNumberish>, amount1: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        allowance(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        approve(spender: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        burn(_shares: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        burnLiquiditySingle(_tickIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claimFee(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        decreaseAllowance(spender: PromiseOrValue<string>, subtractedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        emergencyWithdraw(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, _newTicks: DefiEdgeStrategy.NewTickStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAUMWithFees(_includeFee: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        getTicks(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        increaseAllowance(spender: PromiseOrValue<string>, addedValue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        manager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        mint(_amount0: PromiseOrValue<BigNumberish>, _amount1: PromiseOrValue<BigNumberish>, _amount0Min: PromiseOrValue<BigNumberish>, _amount1Min: PromiseOrValue<BigNumberish>, _minShare: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        onHold(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rebalance(_zeroToOne: PromiseOrValue<boolean>, _amountIn: PromiseOrValue<BigNumberish>, _isOneInchSwap: PromiseOrValue<boolean>, _swapData: PromiseOrValue<BytesLike>, _existingTicks: DefiEdgeStrategy.PartialTickStruct[], _newTicks: DefiEdgeStrategy.NewTickStruct[], _burnAll: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        reserve0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        reserve1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        skim(to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        swap(zeroToOne: PromiseOrValue<boolean>, amountIn: PromiseOrValue<BigNumberish>, isOneInchSwap: PromiseOrValue<boolean>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sync(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        ticks(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transfer(recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        transferFrom(sender: PromiseOrValue<string>, recipient: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        usdAsBase(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}