@stargatefinance/stg-evm-v2 0.1.4 → 0.2.1

package/dist/{StargateBase-3je8TA9F.d.mts → StargateBase-XwK9s6XO.d.mts}

@@ -863,78 +863,107 @@ interface MessagingBase extends BaseContract {
     };
 }
 
-interface OFTTokenInterface extends utils.Interface {
+declare namespace IMultiRewarder {
+    type RewardDetailsStruct = {
+        rewardPerSec: BigNumberish;
+        totalAllocPoints: BigNumberish;
+        start: BigNumberish;
+        end: BigNumberish;
+        exists: boolean;
+    };
+    type RewardDetailsStructOutput = [
+        BigNumber,
+        BigNumber,
+        number,
+        number,
+        boolean
+    ] & {
+        rewardPerSec: BigNumber;
+        totalAllocPoints: BigNumber;
+        start: number;
+        end: number;
+        exists: boolean;
+    };
+}
+interface StargateMultiRewarderInterface extends utils.Interface {
     functions: {
-        "allowance(address,address)": FunctionFragment;
-        "approve(address,uint256)": FunctionFragment;
-        "balanceOf(address)": FunctionFragment;
-        "burnFrom(address,uint256)": FunctionFragment;
-        "decimals()": FunctionFragment;
-        "decreaseAllowance(address,uint256)": FunctionFragment;
-        "increaseAllowance(address,uint256)": FunctionFragment;
-        "mint(address,uint256)": FunctionFragment;
-        "name()": FunctionFragment;
+        "allocPointsByReward(address)": FunctionFragment;
+        "allocPointsByStake(address)": FunctionFragment;
+        "connect(address)": FunctionFragment;
+        "extendReward(address,uint256)": FunctionFragment;
+        "getRewards(address,address)": FunctionFragment;
+        "onUpdate(address,address,uint256,uint256,uint256)": FunctionFragment;
         "owner()": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
-        "symbol()": FunctionFragment;
-        "totalSupply()": FunctionFragment;
-        "transfer(address,uint256)": FunctionFragment;
-        "transferFrom(address,address,uint256)": FunctionFragment;
+        "rewardDetails(address)": FunctionFragment;
+        "rewardTokens()": FunctionFragment;
+        "setAllocPoints(address,address[],uint48[])": FunctionFragment;
+        "setReward(address,uint256,uint48,uint48)": FunctionFragment;
+        "staking()": FunctionFragment;
+        "stopReward(address,address,bool)": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "allowance" | "approve" | "balanceOf" | "burnFrom" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "mint" | "name" | "owner" | "renounceOwnership" | "symbol" | "totalSupply" | "transfer" | "transferFrom" | "transferOwnership"): FunctionFragment;
-    encodeFunctionData(functionFragment: "allowance", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
-    encodeFunctionData(functionFragment: "burnFrom", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
-    encodeFunctionData(functionFragment: "decreaseAllowance", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "increaseAllowance", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "mint", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    getFunction(nameOrSignatureOrTopic: "allocPointsByReward" | "allocPointsByStake" | "connect" | "extendReward" | "getRewards" | "onUpdate" | "owner" | "renounceOwnership" | "rewardDetails" | "rewardTokens" | "setAllocPoints" | "setReward" | "staking" | "stopReward" | "transferOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "allocPointsByReward", values: [string]): string;
+    encodeFunctionData(functionFragment: "allocPointsByStake", values: [string]): string;
+    encodeFunctionData(functionFragment: "connect", values: [string]): string;
+    encodeFunctionData(functionFragment: "extendReward", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getRewards", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "onUpdate", values: [string, string, BigNumberish, BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
-    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
-    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
-    encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "rewardDetails", values: [string]): string;
+    encodeFunctionData(functionFragment: "rewardTokens", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setAllocPoints", values: [string, string[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "setReward", values: [string, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "staking", values?: undefined): string;
+    encodeFunctionData(functionFragment: "stopReward", values: [string, string, boolean]): string;
     encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allocPointsByReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allocPointsByStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "connect", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "extendReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onUpdate", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardDetails", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setAllocPoints", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stopReward", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     events: {
-        "Approval(address,address,uint256)": EventFragment;
+        "AllocPointsSet(address,address[],uint48[])": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
-        "Transfer(address,address,uint256)": EventFragment;
+        "PoolRegistered(address,address)": EventFragment;
+        "RewardExtended(address,uint256,uint48)": EventFragment;
+        "RewardRegistrered(address)": EventFragment;
+        "RewardSet(address,uint256,uint256,uint48,uint48)": EventFragment;
+        "RewarderConnected(address)": EventFragment;
+        "RewardsClaimed(address,address[],uint256[])": EventFragment;
     };
-    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "AllocPointsSet"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PoolRegistered"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardExtended"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardRegistrered"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewarderConnected"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardsClaimed"): EventFragment;
 }
-interface ApprovalEventObject {
-    owner: string;
-    spender: string;
-    value: BigNumber;
+interface AllocPointsSetEventObject {
+    rewardToken: string;
+    stakeToken: string[];
+    allocPoint: number[];
 }
-type ApprovalEvent = TypedEvent<[
-    string,
+type AllocPointsSetEvent = TypedEvent<[
     string,
-    BigNumber
-], ApprovalEventObject>;
-type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+    string[],
+    number[]
+], AllocPointsSetEventObject>;
+type AllocPointsSetEventFilter = TypedEventFilter<AllocPointsSetEvent>;
 interface OwnershipTransferredEventObject$4 {
     previousOwner: string;
     newOwner: string;
@@ -944,22 +973,71 @@ type OwnershipTransferredEvent$4 = TypedEvent<[
     string
 ], OwnershipTransferredEventObject$4>;
 type OwnershipTransferredEventFilter$4 = TypedEventFilter<OwnershipTransferredEvent$4>;
-interface TransferEventObject {
-    from: string;
-    to: string;
-    value: BigNumber;
+interface PoolRegisteredEventObject {
+    rewardToken: string;
+    stakeToken: string;
 }
-type TransferEvent = TypedEvent<[
+type PoolRegisteredEvent = TypedEvent<[
     string,
+    string
+], PoolRegisteredEventObject>;
+type PoolRegisteredEventFilter = TypedEventFilter<PoolRegisteredEvent>;
+interface RewardExtendedEventObject {
+    rewardToken: string;
+    amountAdded: BigNumber;
+    newEnd: number;
+}
+type RewardExtendedEvent = TypedEvent<[
     string,
-    BigNumber
-], TransferEventObject>;
-type TransferEventFilter = TypedEventFilter<TransferEvent>;
-interface OFTToken extends BaseContract {
+    BigNumber,
+    number
+], RewardExtendedEventObject>;
+type RewardExtendedEventFilter = TypedEventFilter<RewardExtendedEvent>;
+interface RewardRegistreredEventObject {
+    rewardToken: string;
+}
+type RewardRegistreredEvent = TypedEvent<[
+    string
+], RewardRegistreredEventObject>;
+type RewardRegistreredEventFilter = TypedEventFilter<RewardRegistreredEvent>;
+interface RewardSetEventObject {
+    rewardToken: string;
+    amountAdded: BigNumber;
+    amountPeriod: BigNumber;
+    start: number;
+    duration: number;
+}
+type RewardSetEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    number,
+    number
+], RewardSetEventObject>;
+type RewardSetEventFilter = TypedEventFilter<RewardSetEvent>;
+interface RewarderConnectedEventObject {
+    stakingToken: string;
+}
+type RewarderConnectedEvent = TypedEvent<[
+    string
+], RewarderConnectedEventObject>;
+type RewarderConnectedEventFilter = TypedEventFilter<RewarderConnectedEvent>;
+interface RewardsClaimedEventObject {
+    user: string;
+    rewardTokens: string[];
+    amounts: BigNumber[];
+}
+type RewardsClaimedEvent = TypedEvent<[
+    string,
+    string[],
+    BigNumber[]
+], RewardsClaimedEventObject>;
+type RewardsClaimedEventFilter = TypedEventFilter<RewardsClaimedEvent>;
+interface StargateMultiRewarder extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
     deployed(): Promise<this>;
-    interface: OFTTokenInterface;
+    interface: StargateMultiRewarderInterface;
     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>;
@@ -970,131 +1048,122 @@ interface OFTToken extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
-        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<[BigNumber]>;
-        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
-        burnFrom(_account: string, _amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        decimals(overrides?: CallOverrides): Promise<[number]>;
-        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
+        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+        connect(stakingToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
+        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        mint(_to: string, _qty: BigNumberish, overrides?: Overrides & {
+        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
+        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        name(overrides?: CallOverrides): Promise<[string]>;
         owner(overrides?: CallOverrides): Promise<[string]>;
-        renounceOwnership(overrides?: Overrides & {
+        renounceOwnership(overrides?: CallOverrides): Promise<[void]>;
+        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<[IMultiRewarder.RewardDetailsStructOutput]>;
+        rewardTokens(overrides?: CallOverrides): Promise<[string[]]>;
+        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        symbol(overrides?: CallOverrides): Promise<[string]>;
-        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
-        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        staking(overrides?: CallOverrides): Promise<[string]>;
+        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
     };
-    allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
-    approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
+    allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+    allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+    extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
-    burnFrom(_account: string, _amount: BigNumberish, overrides?: Overrides & {
+    getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
+    onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    decimals(overrides?: CallOverrides): Promise<number>;
-    decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
+    owner(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: CallOverrides): Promise<void>;
+    rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<IMultiRewarder.RewardDetailsStructOutput>;
+    rewardTokens(overrides?: CallOverrides): Promise<string[]>;
+    setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
+    setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    mint(_to: string, _qty: BigNumberish, overrides?: Overrides & {
+    staking(overrides?: CallOverrides): Promise<string>;
+    stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    name(overrides?: CallOverrides): Promise<string>;
-    owner(overrides?: CallOverrides): Promise<string>;
-    renounceOwnership(overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    symbol(overrides?: CallOverrides): Promise<string>;
-    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
-    transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    transferOwnership(newOwner: string, overrides?: Overrides & {
+    transferOwnership(newOwner: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
     callStatic: {
-        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
-        approve(spender: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
-        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
-        burnFrom(_account: string, _amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        decimals(overrides?: CallOverrides): Promise<number>;
-        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
-        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
-        mint(_to: string, _qty: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        name(overrides?: CallOverrides): Promise<string>;
+        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
+        connect(stakingToken: string, overrides?: CallOverrides): Promise<void>;
+        extendReward(rewardToken: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
+        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: CallOverrides): Promise<void>;
         owner(overrides?: CallOverrides): Promise<string>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
-        symbol(overrides?: CallOverrides): Promise<string>;
-        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
-        transfer(to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
-        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<IMultiRewarder.RewardDetailsStructOutput>;
+        rewardTokens(overrides?: CallOverrides): Promise<string[]>;
+        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: CallOverrides): Promise<void>;
+        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        staking(overrides?: CallOverrides): Promise<string>;
+        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: CallOverrides): Promise<void>;
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
-        "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
-        Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
+        "AllocPointsSet(address,address[],uint48[])"(rewardToken?: string | null, stakeToken?: string[] | null, allocPoint?: null): AllocPointsSetEventFilter;
+        AllocPointsSet(rewardToken?: string | null, stakeToken?: string[] | null, allocPoint?: null): AllocPointsSetEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$4;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$4;
-        "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
-        Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
+        "PoolRegistered(address,address)"(rewardToken?: string | null, stakeToken?: string | null): PoolRegisteredEventFilter;
+        PoolRegistered(rewardToken?: string | null, stakeToken?: string | null): PoolRegisteredEventFilter;
+        "RewardExtended(address,uint256,uint48)"(rewardToken?: string | null, amountAdded?: null, newEnd?: null): RewardExtendedEventFilter;
+        RewardExtended(rewardToken?: string | null, amountAdded?: null, newEnd?: null): RewardExtendedEventFilter;
+        "RewardRegistrered(address)"(rewardToken?: string | null): RewardRegistreredEventFilter;
+        RewardRegistrered(rewardToken?: string | null): RewardRegistreredEventFilter;
+        "RewardSet(address,uint256,uint256,uint48,uint48)"(rewardToken?: string | null, amountAdded?: null, amountPeriod?: null, start?: null, duration?: null): RewardSetEventFilter;
+        RewardSet(rewardToken?: string | null, amountAdded?: null, amountPeriod?: null, start?: null, duration?: null): RewardSetEventFilter;
+        "RewarderConnected(address)"(stakingToken?: string | null): RewarderConnectedEventFilter;
+        RewarderConnected(stakingToken?: string | null): RewarderConnectedEventFilter;
+        "RewardsClaimed(address,address[],uint256[])"(user?: string | null, rewardTokens?: null, amounts?: null): RewardsClaimedEventFilter;
+        RewardsClaimed(user?: string | null, rewardTokens?: null, amounts?: null): RewardsClaimedEventFilter;
     };
     estimateGas: {
-        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
-        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
-        burnFrom(_account: string, _amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        decimals(overrides?: CallOverrides): Promise<BigNumber>;
-        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
+        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<BigNumber>;
+        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<BigNumber>;
+        connect(stakingToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
+        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<BigNumber>;
-        mint(_to: string, _qty: BigNumberish, overrides?: Overrides & {
+        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
+        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        name(overrides?: CallOverrides): Promise<BigNumber>;
         owner(overrides?: CallOverrides): Promise<BigNumber>;
-        renounceOwnership(overrides?: Overrides & {
+        renounceOwnership(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<BigNumber>;
+        rewardTokens(overrides?: CallOverrides): Promise<BigNumber>;
+        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        symbol(overrides?: CallOverrides): Promise<BigNumber>;
-        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
-        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<BigNumber>;
-        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        staking(overrides?: CallOverrides): Promise<BigNumber>;
+        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
@@ -1102,35 +1171,30 @@ interface OFTToken extends BaseContract {
         }): Promise<BigNumber>;
     };
     populateTransaction: {
-        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        balanceOf(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        burnFrom(_account: string, _amount: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
+        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        connect(stakingToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
+        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        mint(_to: string, _qty: BigNumberish, overrides?: Overrides & {
+        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        renounceOwnership(overrides?: Overrides & {
+        renounceOwnership(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        staking(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
@@ -1139,107 +1203,85 @@ interface OFTToken extends BaseContract {
     };
 }
 
-declare namespace IMultiRewarder {
-    type RewardDetailsStruct = {
-        rewardPerSec: BigNumberish;
-        totalAllocPoints: BigNumberish;
-        start: BigNumberish;
-        end: BigNumberish;
-        exists: boolean;
-    };
-    type RewardDetailsStructOutput = [
-        BigNumber,
-        BigNumber,
-        number,
-        number,
-        boolean
-    ] & {
-        rewardPerSec: BigNumber;
-        totalAllocPoints: BigNumber;
-        start: number;
-        end: number;
-        exists: boolean;
-    };
-}
-interface StargateMultiRewarderInterface extends utils.Interface {
+interface StargateStakingInterface extends utils.Interface {
     functions: {
-        "allocPointsByReward(address)": FunctionFragment;
-        "allocPointsByStake(address)": FunctionFragment;
-        "connect(address)": FunctionFragment;
-        "extendReward(address,uint256)": FunctionFragment;
-        "getRewards(address,address)": FunctionFragment;
-        "onUpdate(address,address,uint256,uint256,uint256)": FunctionFragment;
+        "balanceOf(address,address)": FunctionFragment;
+        "claim(address[])": FunctionFragment;
+        "deposit(address,uint256)": FunctionFragment;
+        "depositTo(address,address,uint256)": FunctionFragment;
+        "emergencyWithdraw(address)": FunctionFragment;
+        "isPool(address)": FunctionFragment;
         "owner()": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
-        "rewardDetails(address)": FunctionFragment;
-        "rewardTokens()": FunctionFragment;
-        "setAllocPoints(address,address[],uint48[])": FunctionFragment;
-        "setReward(address,uint256,uint48,uint48)": FunctionFragment;
-        "staking()": FunctionFragment;
-        "stopReward(address,address,bool)": FunctionFragment;
+        "rewarder(address)": FunctionFragment;
+        "setPool(address,address)": FunctionFragment;
+        "tokens(uint256,uint256)": FunctionFragment;
+        "tokens()": FunctionFragment;
+        "tokensLength()": FunctionFragment;
+        "totalSupply(address)": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
+        "withdraw(address,uint256)": FunctionFragment;
+        "withdrawToAndCall(address,address,uint256,bytes)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "allocPointsByReward" | "allocPointsByStake" | "connect" | "extendReward" | "getRewards" | "onUpdate" | "owner" | "renounceOwnership" | "rewardDetails" | "rewardTokens" | "setAllocPoints" | "setReward" | "staking" | "stopReward" | "transferOwnership"): FunctionFragment;
-    encodeFunctionData(functionFragment: "allocPointsByReward", values: [string]): string;
-    encodeFunctionData(functionFragment: "allocPointsByStake", values: [string]): string;
-    encodeFunctionData(functionFragment: "connect", values: [string]): string;
-    encodeFunctionData(functionFragment: "extendReward", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "getRewards", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "onUpdate", values: [string, string, BigNumberish, BigNumberish, BigNumberish]): string;
+    getFunction(nameOrSignatureOrTopic: "balanceOf" | "claim" | "deposit" | "depositTo" | "emergencyWithdraw" | "isPool" | "owner" | "renounceOwnership" | "rewarder" | "setPool" | "tokens(uint256,uint256)" | "tokens()" | "tokensLength" | "totalSupply" | "transferOwnership" | "withdraw" | "withdrawToAndCall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "balanceOf", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "claim", values: [string[]]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "depositTo", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "emergencyWithdraw", values: [string]): string;
+    encodeFunctionData(functionFragment: "isPool", values: [string]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
-    encodeFunctionData(functionFragment: "rewardDetails", values: [string]): string;
-    encodeFunctionData(functionFragment: "rewardTokens", values?: undefined): string;
-    encodeFunctionData(functionFragment: "setAllocPoints", values: [string, string[], BigNumberish[]]): string;
-    encodeFunctionData(functionFragment: "setReward", values: [string, BigNumberish, BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "staking", values?: undefined): string;
-    encodeFunctionData(functionFragment: "stopReward", values: [string, string, boolean]): string;
+    encodeFunctionData(functionFragment: "rewarder", values: [string]): string;
+    encodeFunctionData(functionFragment: "setPool", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "tokens(uint256,uint256)", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "tokens()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tokensLength", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values: [string]): string;
     encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    decodeFunctionResult(functionFragment: "allocPointsByReward", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "allocPointsByStake", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "connect", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "extendReward", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "getRewards", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "onUpdate", data: BytesLike): Result;
+    encodeFunctionData(functionFragment: "withdraw", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawToAndCall", values: [string, string, BigNumberish, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isPool", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "rewardDetails", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "rewardTokens", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "setAllocPoints", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "setReward", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "stopReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewarder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokens(uint256,uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokens()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tokensLength", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawToAndCall", data: BytesLike): Result;
     events: {
-        "AllocPointsSet(address,address[],uint48[])": EventFragment;
+        "Deposit(address,address,address,uint256)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
-        "PoolRegistered(address,address)": EventFragment;
-        "RewardExtended(address,uint256,uint48)": EventFragment;
-        "RewardRegistrered(address)": EventFragment;
-        "RewardSet(address,uint256,uint256,uint48,uint48)": EventFragment;
-        "RewarderConnected(address)": EventFragment;
-        "RewardsClaimed(address,address[],uint256[])": EventFragment;
+        "PoolSet(address,address,bool)": EventFragment;
+        "Withdraw(address,address,address,uint256,bool)": EventFragment;
     };
-    getEvent(nameOrSignatureOrTopic: "AllocPointsSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "PoolRegistered"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "RewardExtended"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "RewardRegistrered"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "RewardSet"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "RewarderConnected"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "RewardsClaimed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PoolSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
 }
-interface AllocPointsSetEventObject {
-    rewardToken: string;
-    stakeToken: string[];
-    allocPoint: number[];
+interface DepositEventObject {
+    token: string;
+    from: string;
+    to: string;
+    amount: BigNumber;
 }
-type AllocPointsSetEvent = TypedEvent<[
+type DepositEvent = TypedEvent<[
     string,
-    string[],
-    number[]
-], AllocPointsSetEventObject>;
-type AllocPointsSetEventFilter = TypedEventFilter<AllocPointsSetEvent>;
+    string,
+    string,
+    BigNumber
+], DepositEventObject>;
+type DepositEventFilter = TypedEventFilter<DepositEvent>;
 interface OwnershipTransferredEventObject$3 {
     previousOwner: string;
     newOwner: string;
@@ -1249,71 +1291,37 @@ type OwnershipTransferredEvent$3 = TypedEvent<[
     string
 ], OwnershipTransferredEventObject$3>;
 type OwnershipTransferredEventFilter$3 = TypedEventFilter<OwnershipTransferredEvent$3>;
-interface PoolRegisteredEventObject {
-    rewardToken: string;
-    stakeToken: string;
-}
-type PoolRegisteredEvent = TypedEvent<[
-    string,
-    string
-], PoolRegisteredEventObject>;
-type PoolRegisteredEventFilter = TypedEventFilter<PoolRegisteredEvent>;
-interface RewardExtendedEventObject {
-    rewardToken: string;
-    amountAdded: BigNumber;
-    newEnd: number;
+interface PoolSetEventObject {
+    token: string;
+    rewarder: string;
+    exists: boolean;
 }
-type RewardExtendedEvent = TypedEvent<[
+type PoolSetEvent = TypedEvent<[
     string,
-    BigNumber,
-    number
-], RewardExtendedEventObject>;
-type RewardExtendedEventFilter = TypedEventFilter<RewardExtendedEvent>;
-interface RewardRegistreredEventObject {
-    rewardToken: string;
-}
-type RewardRegistreredEvent = TypedEvent<[
-    string
-], RewardRegistreredEventObject>;
-type RewardRegistreredEventFilter = TypedEventFilter<RewardRegistreredEvent>;
-interface RewardSetEventObject {
-    rewardToken: string;
-    amountAdded: BigNumber;
-    amountPeriod: BigNumber;
-    start: number;
-    duration: number;
-}
-type RewardSetEvent = TypedEvent<[
     string,
-    BigNumber,
-    BigNumber,
-    number,
-    number
-], RewardSetEventObject>;
-type RewardSetEventFilter = TypedEventFilter<RewardSetEvent>;
-interface RewarderConnectedEventObject {
-    stakingToken: string;
-}
-type RewarderConnectedEvent = TypedEvent<[
-    string
-], RewarderConnectedEventObject>;
-type RewarderConnectedEventFilter = TypedEventFilter<RewarderConnectedEvent>;
-interface RewardsClaimedEventObject {
-    user: string;
-    rewardTokens: string[];
-    amounts: BigNumber[];
+    boolean
+], PoolSetEventObject>;
+type PoolSetEventFilter = TypedEventFilter<PoolSetEvent>;
+interface WithdrawEventObject {
+    token: string;
+    from: string;
+    to: string;
+    amount: BigNumber;
+    withUpdate: boolean;
 }
-type RewardsClaimedEvent = TypedEvent<[
+type WithdrawEvent = TypedEvent<[
     string,
-    string[],
-    BigNumber[]
-], RewardsClaimedEventObject>;
-type RewardsClaimedEventFilter = TypedEventFilter<RewardsClaimedEvent>;
-interface StargateMultiRewarder extends BaseContract {
+    string,
+    string,
+    BigNumber,
+    boolean
+], WithdrawEventObject>;
+type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
+interface StargateStaking extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
     deployed(): Promise<this>;
-    interface: StargateMultiRewarderInterface;
+    interface: StargateStakingInterface;
     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>;
@@ -1324,240 +1332,276 @@ interface StargateMultiRewarder extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
-        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-        connect(stakingToken: string, overrides?: Overrides & {
+        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        claim(lpTokens: string[], overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
+        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
-        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
+        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        emergencyWithdraw(token: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
+        isPool(token: string, overrides?: CallOverrides): Promise<[boolean]>;
         owner(overrides?: CallOverrides): Promise<[string]>;
         renounceOwnership(overrides?: CallOverrides): Promise<[void]>;
-        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<[IMultiRewarder.RewardDetailsStructOutput]>;
-        rewardTokens(overrides?: CallOverrides): Promise<[string[]]>;
-        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
+        rewarder(token: string, overrides?: CallOverrides): Promise<[string]>;
+        setPool(token: string, newRewarder: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
+        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<[string[]]>;
+        "tokens()"(overrides?: CallOverrides): Promise<[string[]]>;
+        tokensLength(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalSupply(token: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        staking(overrides?: CallOverrides): Promise<[string]>;
-        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
+        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
     };
-    allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-    allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-    extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
+    balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
+    claim(lpTokens: string[], overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
-    onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
+    deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    emergencyWithdraw(token: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
+    isPool(token: string, overrides?: CallOverrides): Promise<boolean>;
     owner(overrides?: CallOverrides): Promise<string>;
     renounceOwnership(overrides?: CallOverrides): Promise<void>;
-    rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<IMultiRewarder.RewardDetailsStructOutput>;
-    rewardTokens(overrides?: CallOverrides): Promise<string[]>;
-    setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
+    rewarder(token: string, overrides?: CallOverrides): Promise<string>;
+    setPool(token: string, newRewarder: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
+    "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+    "tokens()"(overrides?: CallOverrides): Promise<string[]>;
+    tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
+    totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    staking(overrides?: CallOverrides): Promise<string>;
-    stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
+    withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    transferOwnership(newOwner: string, overrides?: Overrides & {
+    withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
     callStatic: {
-        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<[string[], number[]]>;
-        connect(stakingToken: string, overrides?: CallOverrides): Promise<void>;
-        extendReward(rewardToken: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<[string[], BigNumber[]]>;
-        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
+        claim(lpTokens: string[], overrides?: CallOverrides): Promise<void>;
+        deposit(token: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        depositTo(token: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        emergencyWithdraw(token: string, overrides?: CallOverrides): Promise<void>;
+        isPool(token: string, overrides?: CallOverrides): Promise<boolean>;
         owner(overrides?: CallOverrides): Promise<string>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
-        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<IMultiRewarder.RewardDetailsStructOutput>;
-        rewardTokens(overrides?: CallOverrides): Promise<string[]>;
-        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: CallOverrides): Promise<void>;
-        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        staking(overrides?: CallOverrides): Promise<string>;
-        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: CallOverrides): Promise<void>;
+        rewarder(token: string, overrides?: CallOverrides): Promise<string>;
+        setPool(token: string, newRewarder: string, overrides?: CallOverrides): Promise<void>;
+        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
+        "tokens()"(overrides?: CallOverrides): Promise<string[]>;
+        tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
+        totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
+        withdraw(token: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
-        "AllocPointsSet(address,address[],uint48[])"(rewardToken?: string | null, stakeToken?: string[] | null, allocPoint?: null): AllocPointsSetEventFilter;
-        AllocPointsSet(rewardToken?: string | null, stakeToken?: string[] | null, allocPoint?: null): AllocPointsSetEventFilter;
+        "Deposit(address,address,address,uint256)"(token?: string | null, from?: string | null, to?: string | null, amount?: null): DepositEventFilter;
+        Deposit(token?: string | null, from?: string | null, to?: string | null, amount?: null): DepositEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$3;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$3;
-        "PoolRegistered(address,address)"(rewardToken?: string | null, stakeToken?: string | null): PoolRegisteredEventFilter;
-        PoolRegistered(rewardToken?: string | null, stakeToken?: string | null): PoolRegisteredEventFilter;
-        "RewardExtended(address,uint256,uint48)"(rewardToken?: string | null, amountAdded?: null, newEnd?: null): RewardExtendedEventFilter;
-        RewardExtended(rewardToken?: string | null, amountAdded?: null, newEnd?: null): RewardExtendedEventFilter;
-        "RewardRegistrered(address)"(rewardToken?: string | null): RewardRegistreredEventFilter;
-        RewardRegistrered(rewardToken?: string | null): RewardRegistreredEventFilter;
-        "RewardSet(address,uint256,uint256,uint48,uint48)"(rewardToken?: string | null, amountAdded?: null, amountPeriod?: null, start?: null, duration?: null): RewardSetEventFilter;
-        RewardSet(rewardToken?: string | null, amountAdded?: null, amountPeriod?: null, start?: null, duration?: null): RewardSetEventFilter;
-        "RewarderConnected(address)"(stakingToken?: string | null): RewarderConnectedEventFilter;
-        RewarderConnected(stakingToken?: string | null): RewarderConnectedEventFilter;
-        "RewardsClaimed(address,address[],uint256[])"(user?: string | null, rewardTokens?: null, amounts?: null): RewardsClaimedEventFilter;
-        RewardsClaimed(user?: string | null, rewardTokens?: null, amounts?: null): RewardsClaimedEventFilter;
+        "PoolSet(address,address,bool)"(token?: string | null, rewarder?: null, exists?: null): PoolSetEventFilter;
+        PoolSet(token?: string | null, rewarder?: null, exists?: null): PoolSetEventFilter;
+        "Withdraw(address,address,address,uint256,bool)"(token?: string | null, from?: string | null, to?: string | null, amount?: null, withUpdate?: null): WithdrawEventFilter;
+        Withdraw(token?: string | null, from?: string | null, to?: string | null, amount?: null, withUpdate?: null): WithdrawEventFilter;
     };
     estimateGas: {
-        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<BigNumber>;
-        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<BigNumber>;
-        connect(stakingToken: string, overrides?: Overrides & {
+        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
+        claim(lpTokens: string[], overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
+        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
-        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
+        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        emergencyWithdraw(token: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
+        isPool(token: string, overrides?: CallOverrides): Promise<BigNumber>;
         owner(overrides?: CallOverrides): Promise<BigNumber>;
         renounceOwnership(overrides?: CallOverrides): Promise<BigNumber>;
-        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<BigNumber>;
-        rewardTokens(overrides?: CallOverrides): Promise<BigNumber>;
-        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
+        rewarder(token: string, overrides?: CallOverrides): Promise<BigNumber>;
+        setPool(token: string, newRewarder: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
+        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        "tokens()"(overrides?: CallOverrides): Promise<BigNumber>;
+        tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
+        totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        staking(overrides?: CallOverrides): Promise<BigNumber>;
-        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
+        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
     };
     populateTransaction: {
-        allocPointsByReward(rewardToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        allocPointsByStake(stakingToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        connect(stakingToken: string, overrides?: Overrides & {
+        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        claim(lpTokens: string[], overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        extendReward(rewardToken: string, amount: BigNumberish, overrides?: PayableOverrides & {
+        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        getRewards(stakingToken: string, user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        onUpdate(stakingToken: string, user: string, oldStake: BigNumberish, oldSupply: BigNumberish, arg4: BigNumberish, overrides?: Overrides & {
+        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        emergencyWithdraw(token: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
+        isPool(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         renounceOwnership(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        rewardDetails(rewardToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        rewardTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        setAllocPoints(rewardToken: string, stakingTokens: string[], allocPoints: BigNumberish[], overrides?: Overrides & {
+        rewarder(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setPool(token: string, newRewarder: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        setReward(rewardToken: string, amount: BigNumberish, start: BigNumberish, duration: BigNumberish, overrides?: PayableOverrides & {
+        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "tokens()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tokensLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalSupply(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        staking(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        stopReward(rewardToken: string, receiver: string, pullTokens: boolean, overrides?: Overrides & {
+        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
     };
 }
 
-interface StargateStakingInterface extends utils.Interface {
+interface StargateZapperV1Interface extends utils.Interface {
     functions: {
-        "balanceOf(address,address)": FunctionFragment;
-        "claim(address[])": FunctionFragment;
-        "deposit(address,uint256)": FunctionFragment;
-        "depositTo(address,address,uint256)": FunctionFragment;
-        "emergencyWithdraw(address)": FunctionFragment;
-        "isPool(address)": FunctionFragment;
-        "owner()": FunctionFragment;
-        "renounceOwnership()": FunctionFragment;
-        "rewarder(address)": FunctionFragment;
-        "setPool(address,address)": FunctionFragment;
-        "tokens(uint256,uint256)": FunctionFragment;
-        "tokens()": FunctionFragment;
-        "tokensLength()": FunctionFragment;
-        "totalSupply(address)": FunctionFragment;
+        "configureLpToken(address,bool)": FunctionFragment;
+        "configureV1Pool(uint16,address)": FunctionFragment;
+        "depositAndStake(address,uint256,uint256)": FunctionFragment;
+        "depositAndStakeWithPermit(address,uint256,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
+        "ethVault()": FunctionFragment;
+        "factoryV1()": FunctionFragment;
+        "lpToAsset(address)": FunctionFragment;
+        "lpToPool(address)": FunctionFragment;
+        "migrateV1LpToV2Stake(uint16,uint256,uint256)": FunctionFragment;
+        "migrateV1LpToV2StakeWithPermit(uint16,uint256,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
+        "onWithdrawReceived(address,address,uint256,bytes)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "routerV1()": FunctionFragment;
+        "staking()": FunctionFragment;
+        "sweep(address,address,uint256)": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
-        "withdraw(address,uint256)": FunctionFragment;
-        "withdrawToAndCall(address,address,uint256,bytes)": FunctionFragment;
+        "v1PidToConversionRate(uint16)": FunctionFragment;
+        "v1PidToV1Lp(uint16)": FunctionFragment;
+        "v1PidToV2Lp(uint16)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "balanceOf" | "claim" | "deposit" | "depositTo" | "emergencyWithdraw" | "isPool" | "owner" | "renounceOwnership" | "rewarder" | "setPool" | "tokens(uint256,uint256)" | "tokens()" | "tokensLength" | "totalSupply" | "transferOwnership" | "withdraw" | "withdrawToAndCall"): FunctionFragment;
-    encodeFunctionData(functionFragment: "balanceOf", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "claim", values: [string[]]): string;
-    encodeFunctionData(functionFragment: "deposit", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "depositTo", values: [string, string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "emergencyWithdraw", values: [string]): string;
-    encodeFunctionData(functionFragment: "isPool", values: [string]): string;
+    getFunction(nameOrSignatureOrTopic: "configureLpToken" | "configureV1Pool" | "depositAndStake" | "depositAndStakeWithPermit" | "ethVault" | "factoryV1" | "lpToAsset" | "lpToPool" | "migrateV1LpToV2Stake" | "migrateV1LpToV2StakeWithPermit" | "onWithdrawReceived" | "owner" | "renounceOwnership" | "routerV1" | "staking" | "sweep" | "transferOwnership" | "v1PidToConversionRate" | "v1PidToV1Lp" | "v1PidToV2Lp"): FunctionFragment;
+    encodeFunctionData(functionFragment: "configureLpToken", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "configureV1Pool", values: [BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "depositAndStake", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "depositAndStakeWithPermit", values: [
+        string,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "ethVault", values?: undefined): string;
+    encodeFunctionData(functionFragment: "factoryV1", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lpToAsset", values: [string]): string;
+    encodeFunctionData(functionFragment: "lpToPool", values: [string]): string;
+    encodeFunctionData(functionFragment: "migrateV1LpToV2Stake", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "migrateV1LpToV2StakeWithPermit", values: [
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "onWithdrawReceived", values: [string, string, BigNumberish, BytesLike]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
-    encodeFunctionData(functionFragment: "rewarder", values: [string]): string;
-    encodeFunctionData(functionFragment: "setPool", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "tokens(uint256,uint256)", values: [BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "tokens()", values?: undefined): string;
-    encodeFunctionData(functionFragment: "tokensLength", values?: undefined): string;
-    encodeFunctionData(functionFragment: "totalSupply", values: [string]): string;
+    encodeFunctionData(functionFragment: "routerV1", values?: undefined): string;
+    encodeFunctionData(functionFragment: "staking", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sweep", values: [string, string, BigNumberish]): string;
     encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    encodeFunctionData(functionFragment: "withdraw", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "withdrawToAndCall", values: [string, string, BigNumberish, BytesLike]): string;
-    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "depositTo", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "isPool", data: BytesLike): Result;
+    encodeFunctionData(functionFragment: "v1PidToConversionRate", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "v1PidToV1Lp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "v1PidToV2Lp", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "configureLpToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "configureV1Pool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositAndStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositAndStakeWithPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ethVault", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "factoryV1", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lpToAsset", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lpToPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "migrateV1LpToV2Stake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "migrateV1LpToV2StakeWithPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onWithdrawReceived", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "rewarder", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "setPool", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "tokens(uint256,uint256)", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "tokens()", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "tokensLength", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "routerV1", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweep", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "withdrawToAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "v1PidToConversionRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "v1PidToV1Lp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "v1PidToV2Lp", data: BytesLike): Result;
     events: {
-        "Deposit(address,address,address,uint256)": EventFragment;
+        "LpConfigured(address,address,address)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
-        "PoolSet(address,address,bool)": EventFragment;
-        "Withdraw(address,address,address,uint256,bool)": EventFragment;
+        "TokenSwept(address,address,uint256)": EventFragment;
+        "V1PoolConfigured(uint16,address,address)": EventFragment;
     };
-    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "LpConfigured"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "PoolSet"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TokenSwept"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "V1PoolConfigured"): EventFragment;
 }
-interface DepositEventObject {
-    token: string;
-    from: string;
-    to: string;
-    amount: BigNumber;
+interface LpConfiguredEventObject {
+    lpToken: string;
+    pool: string;
+    asset: string;
 }
-type DepositEvent = TypedEvent<[
-    string,
+type LpConfiguredEvent = TypedEvent<[
     string,
     string,
-    BigNumber
-], DepositEventObject>;
-type DepositEventFilter = TypedEventFilter<DepositEvent>;
+    string
+], LpConfiguredEventObject>;
+type LpConfiguredEventFilter = TypedEventFilter<LpConfiguredEvent>;
 interface OwnershipTransferredEventObject$2 {
     previousOwner: string;
     newOwner: string;
@@ -1567,37 +1611,33 @@ type OwnershipTransferredEvent$2 = TypedEvent<[
     string
 ], OwnershipTransferredEventObject$2>;
 type OwnershipTransferredEventFilter$2 = TypedEventFilter<OwnershipTransferredEvent$2>;
-interface PoolSetEventObject {
-    token: string;
-    rewarder: string;
-    exists: boolean;
-}
-type PoolSetEvent = TypedEvent<[
-    string,
-    string,
-    boolean
-], PoolSetEventObject>;
-type PoolSetEventFilter = TypedEventFilter<PoolSetEvent>;
-interface WithdrawEventObject {
+interface TokenSweptEventObject {
     token: string;
-    from: string;
-    to: string;
+    receiver: string;
     amount: BigNumber;
-    withUpdate: boolean;
 }
-type WithdrawEvent = TypedEvent<[
+type TokenSweptEvent = TypedEvent<[
     string,
     string,
+    BigNumber
+], TokenSweptEventObject>;
+type TokenSweptEventFilter = TypedEventFilter<TokenSweptEvent>;
+interface V1PoolConfiguredEventObject {
+    poolId: number;
+    v1LpToken: string;
+    v2LpToken: string;
+}
+type V1PoolConfiguredEvent = TypedEvent<[
+    number,
     string,
-    BigNumber,
-    boolean
-], WithdrawEventObject>;
-type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
-interface StargateStaking extends BaseContract {
+    string
+], V1PoolConfiguredEventObject>;
+type V1PoolConfiguredEventFilter = TypedEventFilter<V1PoolConfiguredEvent>;
+interface StargateZapperV1 extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
     deployed(): Promise<this>;
-    interface: StargateStakingInterface;
+    interface: StargateZapperV1Interface;
     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>;
@@ -1608,276 +1648,310 @@ interface StargateStaking extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
-        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<[BigNumber]>;
-        claim(lpTokens: string[], overrides?: Overrides & {
+        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
+        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        emergencyWithdraw(token: string, overrides?: Overrides & {
+        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        isPool(token: string, overrides?: CallOverrides): Promise<[boolean]>;
-        owner(overrides?: CallOverrides): Promise<[string]>;
-        renounceOwnership(overrides?: CallOverrides): Promise<[void]>;
-        rewarder(token: string, overrides?: CallOverrides): Promise<[string]>;
-        setPool(token: string, newRewarder: string, overrides?: Overrides & {
+        ethVault(overrides?: CallOverrides): Promise<[string]>;
+        factoryV1(overrides?: CallOverrides): Promise<[string]>;
+        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<[string] & {
+            asset: string;
+        }>;
+        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<[string] & {
+            pool: string;
+        }>;
+        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<[string[]]>;
-        "tokens()"(overrides?: CallOverrides): Promise<[string[]]>;
-        tokensLength(overrides?: CallOverrides): Promise<[BigNumber]>;
-        totalSupply(token: string, overrides?: CallOverrides): Promise<[BigNumber]>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
+        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
+        routerV1(overrides?: CallOverrides): Promise<[string]>;
+        staking(overrides?: CallOverrides): Promise<[string]>;
+        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
+            conversionRate: BigNumber;
+        }>;
+        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
+            lpToken: string;
+        }>;
+        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
+            lpToken: string;
+        }>;
     };
-    balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
-    claim(lpTokens: string[], overrides?: Overrides & {
+    configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
+    configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+    depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    emergencyWithdraw(token: string, overrides?: Overrides & {
+    depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    isPool(token: string, overrides?: CallOverrides): Promise<boolean>;
-    owner(overrides?: CallOverrides): Promise<string>;
-    renounceOwnership(overrides?: CallOverrides): Promise<void>;
-    rewarder(token: string, overrides?: CallOverrides): Promise<string>;
-    setPool(token: string, newRewarder: string, overrides?: Overrides & {
+    ethVault(overrides?: CallOverrides): Promise<string>;
+    factoryV1(overrides?: CallOverrides): Promise<string>;
+    lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<string>;
+    lpToPool(lpToken: string, overrides?: CallOverrides): Promise<string>;
+    migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
-    "tokens()"(overrides?: CallOverrides): Promise<string[]>;
-    tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
-    totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
-    transferOwnership(newOwner: string, overrides?: Overrides & {
+    migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
+    onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
+    owner(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    routerV1(overrides?: CallOverrides): Promise<string>;
+    staking(overrides?: CallOverrides): Promise<string>;
+    sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
     callStatic: {
-        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
-        claim(lpTokens: string[], overrides?: CallOverrides): Promise<void>;
-        deposit(token: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        depositTo(token: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        emergencyWithdraw(token: string, overrides?: CallOverrides): Promise<void>;
-        isPool(token: string, overrides?: CallOverrides): Promise<boolean>;
+        configureLpToken(lpToken: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
+        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: CallOverrides): Promise<void>;
+        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
+        ethVault(overrides?: CallOverrides): Promise<string>;
+        factoryV1(overrides?: CallOverrides): Promise<string>;
+        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<string>;
+        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<string>;
+        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
+        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<string>;
         owner(overrides?: CallOverrides): Promise<string>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
-        rewarder(token: string, overrides?: CallOverrides): Promise<string>;
-        setPool(token: string, newRewarder: string, overrides?: CallOverrides): Promise<void>;
-        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<string[]>;
-        "tokens()"(overrides?: CallOverrides): Promise<string[]>;
-        tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
-        totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
+        routerV1(overrides?: CallOverrides): Promise<string>;
+        staking(overrides?: CallOverrides): Promise<string>;
+        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
-        withdraw(token: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
     };
     filters: {
-        "Deposit(address,address,address,uint256)"(token?: string | null, from?: string | null, to?: string | null, amount?: null): DepositEventFilter;
-        Deposit(token?: string | null, from?: string | null, to?: string | null, amount?: null): DepositEventFilter;
+        "LpConfigured(address,address,address)"(lpToken?: string | null, pool?: string | null, asset?: null): LpConfiguredEventFilter;
+        LpConfigured(lpToken?: string | null, pool?: string | null, asset?: null): LpConfiguredEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$2;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$2;
-        "PoolSet(address,address,bool)"(token?: string | null, rewarder?: null, exists?: null): PoolSetEventFilter;
-        PoolSet(token?: string | null, rewarder?: null, exists?: null): PoolSetEventFilter;
-        "Withdraw(address,address,address,uint256,bool)"(token?: string | null, from?: string | null, to?: string | null, amount?: null, withUpdate?: null): WithdrawEventFilter;
-        Withdraw(token?: string | null, from?: string | null, to?: string | null, amount?: null, withUpdate?: null): WithdrawEventFilter;
+        "TokenSwept(address,address,uint256)"(token?: string | null, receiver?: string | null, amount?: null): TokenSweptEventFilter;
+        TokenSwept(token?: string | null, receiver?: string | null, amount?: null): TokenSweptEventFilter;
+        "V1PoolConfigured(uint16,address,address)"(poolId?: BigNumberish | null, v1LpToken?: string | null, v2LpToken?: string | null): V1PoolConfiguredEventFilter;
+        V1PoolConfigured(poolId?: BigNumberish | null, v1LpToken?: string | null, v2LpToken?: string | null): V1PoolConfiguredEventFilter;
     };
     estimateGas: {
-        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<BigNumber>;
-        claim(lpTokens: string[], overrides?: Overrides & {
+        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
+        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<BigNumber>;
-        emergencyWithdraw(token: string, overrides?: Overrides & {
+        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        isPool(token: string, overrides?: CallOverrides): Promise<BigNumber>;
-        owner(overrides?: CallOverrides): Promise<BigNumber>;
-        renounceOwnership(overrides?: CallOverrides): Promise<BigNumber>;
-        rewarder(token: string, overrides?: CallOverrides): Promise<BigNumber>;
-        setPool(token: string, newRewarder: string, overrides?: Overrides & {
+        ethVault(overrides?: CallOverrides): Promise<BigNumber>;
+        factoryV1(overrides?: CallOverrides): Promise<BigNumber>;
+        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<BigNumber>;
+        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<BigNumber>;
+        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<BigNumber>;
-        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        "tokens()"(overrides?: CallOverrides): Promise<BigNumber>;
-        tokensLength(overrides?: CallOverrides): Promise<BigNumber>;
-        totalSupply(token: string, overrides?: CallOverrides): Promise<BigNumber>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
+        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        routerV1(overrides?: CallOverrides): Promise<BigNumber>;
+        staking(overrides?: CallOverrides): Promise<BigNumber>;
+        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
     };
     populateTransaction: {
-        balanceOf(token: string, user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        claim(lpTokens: string[], overrides?: Overrides & {
+        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        deposit(token: string, amount: BigNumberish, overrides?: Overrides & {
+        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        depositTo(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        emergencyWithdraw(token: string, overrides?: Overrides & {
+        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        isPool(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        renounceOwnership(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        rewarder(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        setPool(token: string, newRewarder: string, overrides?: Overrides & {
+        ethVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        factoryV1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        "tokens(uint256,uint256)"(start: BigNumberish, end: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        "tokens()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        tokensLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        totalSupply(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
+        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        withdraw(token: string, amount: BigNumberish, overrides?: Overrides & {
+        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        withdrawToAndCall(token: string, to: string, amount: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        routerV1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        staking(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
+        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
     };
 }
 
-interface StargateZapperV1Interface extends utils.Interface {
+interface OFTTokenERC20Interface extends utils.Interface {
     functions: {
-        "configureLpToken(address,bool)": FunctionFragment;
-        "configureV1Pool(uint16,address)": FunctionFragment;
-        "depositAndStake(address,uint256,uint256)": FunctionFragment;
-        "depositAndStakeWithPermit(address,uint256,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
-        "ethVault()": FunctionFragment;
-        "factoryV1()": FunctionFragment;
-        "lpToAsset(address)": FunctionFragment;
-        "lpToPool(address)": FunctionFragment;
-        "migrateV1LpToV2Stake(uint16,uint256,uint256)": FunctionFragment;
-        "migrateV1LpToV2StakeWithPermit(uint16,uint256,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment;
-        "onWithdrawReceived(address,address,uint256,bytes)": FunctionFragment;
+        "addMinter(address)": FunctionFragment;
+        "allowance(address,address)": FunctionFragment;
+        "approve(address,uint256)": FunctionFragment;
+        "balanceOf(address)": FunctionFragment;
+        "burnFrom(address,uint256)": FunctionFragment;
+        "decimals()": FunctionFragment;
+        "decreaseAllowance(address,uint256)": FunctionFragment;
+        "increaseAllowance(address,uint256)": FunctionFragment;
+        "mint(address,uint256)": FunctionFragment;
+        "minters(address)": FunctionFragment;
+        "name()": FunctionFragment;
         "owner()": FunctionFragment;
+        "removeMinter(address)": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
-        "routerV1()": FunctionFragment;
-        "staking()": FunctionFragment;
-        "sweep(address,address,uint256)": FunctionFragment;
+        "symbol()": FunctionFragment;
+        "totalSupply()": FunctionFragment;
+        "transfer(address,uint256)": FunctionFragment;
+        "transferFrom(address,address,uint256)": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
-        "v1PidToConversionRate(uint16)": FunctionFragment;
-        "v1PidToV1Lp(uint16)": FunctionFragment;
-        "v1PidToV2Lp(uint16)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "configureLpToken" | "configureV1Pool" | "depositAndStake" | "depositAndStakeWithPermit" | "ethVault" | "factoryV1" | "lpToAsset" | "lpToPool" | "migrateV1LpToV2Stake" | "migrateV1LpToV2StakeWithPermit" | "onWithdrawReceived" | "owner" | "renounceOwnership" | "routerV1" | "staking" | "sweep" | "transferOwnership" | "v1PidToConversionRate" | "v1PidToV1Lp" | "v1PidToV2Lp"): FunctionFragment;
-    encodeFunctionData(functionFragment: "configureLpToken", values: [string, boolean]): string;
-    encodeFunctionData(functionFragment: "configureV1Pool", values: [BigNumberish, string]): string;
-    encodeFunctionData(functionFragment: "depositAndStake", values: [string, BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "depositAndStakeWithPermit", values: [
-        string,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BytesLike,
-        BytesLike
-    ]): string;
-    encodeFunctionData(functionFragment: "ethVault", values?: undefined): string;
-    encodeFunctionData(functionFragment: "factoryV1", values?: undefined): string;
-    encodeFunctionData(functionFragment: "lpToAsset", values: [string]): string;
-    encodeFunctionData(functionFragment: "lpToPool", values: [string]): string;
-    encodeFunctionData(functionFragment: "migrateV1LpToV2Stake", values: [BigNumberish, BigNumberish, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "migrateV1LpToV2StakeWithPermit", values: [
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BigNumberish,
-        BytesLike,
-        BytesLike
-    ]): string;
-    encodeFunctionData(functionFragment: "onWithdrawReceived", values: [string, string, BigNumberish, BytesLike]): string;
+    getFunction(nameOrSignatureOrTopic: "addMinter" | "allowance" | "approve" | "balanceOf" | "burnFrom" | "decimals" | "decreaseAllowance" | "increaseAllowance" | "mint" | "minters" | "name" | "owner" | "removeMinter" | "renounceOwnership" | "symbol" | "totalSupply" | "transfer" | "transferFrom" | "transferOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addMinter", values: [string]): string;
+    encodeFunctionData(functionFragment: "allowance", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
+    encodeFunctionData(functionFragment: "burnFrom", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decreaseAllowance", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "increaseAllowance", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "mint", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "minters", values: [string]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "removeMinter", values: [string]): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
-    encodeFunctionData(functionFragment: "routerV1", values?: undefined): string;
-    encodeFunctionData(functionFragment: "staking", values?: undefined): string;
-    encodeFunctionData(functionFragment: "sweep", values: [string, string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    encodeFunctionData(functionFragment: "v1PidToConversionRate", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "v1PidToV1Lp", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "v1PidToV2Lp", values: [BigNumberish]): string;
-    decodeFunctionResult(functionFragment: "configureLpToken", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "configureV1Pool", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "depositAndStake", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "depositAndStakeWithPermit", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "ethVault", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "factoryV1", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "lpToAsset", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "lpToPool", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "migrateV1LpToV2Stake", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "migrateV1LpToV2StakeWithPermit", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "onWithdrawReceived", data: BytesLike): Result;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    decodeFunctionResult(functionFragment: "addMinter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "minters", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeMinter", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "routerV1", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "staking", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "sweep", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "v1PidToConversionRate", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "v1PidToV1Lp", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "v1PidToV2Lp", data: BytesLike): Result;
     events: {
-        "LpConfigured(address,address,address)": EventFragment;
+        "Approval(address,address,uint256)": EventFragment;
+        "MinterAdded(address)": EventFragment;
+        "MinterRemoved(address)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
-        "TokenSwept(address,address,uint256)": EventFragment;
-        "V1PoolConfigured(uint16,address,address)": EventFragment;
+        "Transfer(address,address,uint256)": EventFragment;
     };
-    getEvent(nameOrSignatureOrTopic: "LpConfigured"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MinterAdded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MinterRemoved"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "TokenSwept"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "V1PoolConfigured"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
 }
-interface LpConfiguredEventObject {
-    lpToken: string;
-    pool: string;
-    asset: string;
+interface ApprovalEventObject {
+    owner: string;
+    spender: string;
+    value: BigNumber;
 }
-type LpConfiguredEvent = TypedEvent<[
+type ApprovalEvent = TypedEvent<[
     string,
     string,
-    string
-], LpConfiguredEventObject>;
-type LpConfiguredEventFilter = TypedEventFilter<LpConfiguredEvent>;
+    BigNumber
+], ApprovalEventObject>;
+type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+interface MinterAddedEventObject {
+    minter: string;
+}
+type MinterAddedEvent = TypedEvent<[string], MinterAddedEventObject>;
+type MinterAddedEventFilter = TypedEventFilter<MinterAddedEvent>;
+interface MinterRemovedEventObject {
+    minter: string;
+}
+type MinterRemovedEvent = TypedEvent<[string], MinterRemovedEventObject>;
+type MinterRemovedEventFilter = TypedEventFilter<MinterRemovedEvent>;
 interface OwnershipTransferredEventObject$1 {
     previousOwner: string;
     newOwner: string;
@@ -1887,33 +1961,22 @@ type OwnershipTransferredEvent$1 = TypedEvent<[
     string
 ], OwnershipTransferredEventObject$1>;
 type OwnershipTransferredEventFilter$1 = TypedEventFilter<OwnershipTransferredEvent$1>;
-interface TokenSweptEventObject {
-    token: string;
-    receiver: string;
-    amount: BigNumber;
+interface TransferEventObject {
+    from: string;
+    to: string;
+    value: BigNumber;
 }
-type TokenSweptEvent = TypedEvent<[
+type TransferEvent = TypedEvent<[
     string,
     string,
     BigNumber
-], TokenSweptEventObject>;
-type TokenSweptEventFilter = TypedEventFilter<TokenSweptEvent>;
-interface V1PoolConfiguredEventObject {
-    poolId: number;
-    v1LpToken: string;
-    v2LpToken: string;
-}
-type V1PoolConfiguredEvent = TypedEvent<[
-    number,
-    string,
-    string
-], V1PoolConfiguredEventObject>;
-type V1PoolConfiguredEventFilter = TypedEventFilter<V1PoolConfiguredEvent>;
-interface StargateZapperV1 extends BaseContract {
+], TransferEventObject>;
+type TransferEventFilter = TypedEventFilter<TransferEvent>;
+interface OFTTokenERC20 extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
     deployed(): Promise<this>;
-    interface: StargateZapperV1Interface;
+    interface: OFTTokenERC20Interface;
     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>;
@@ -1924,212 +1987,209 @@ interface StargateZapperV1 extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
-        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
+        addMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
+        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        burnFrom(_account: string, _value: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        decimals(overrides?: CallOverrides): Promise<[number]>;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        ethVault(overrides?: CallOverrides): Promise<[string]>;
-        factoryV1(overrides?: CallOverrides): Promise<[string]>;
-        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<[string] & {
-            asset: string;
-        }>;
-        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<[string] & {
-            pool: string;
-        }>;
-        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        mint(_account: string, _amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        minters(addr: string, overrides?: CallOverrides): Promise<[boolean] & {
+            canMint: boolean;
+        }>;
+        name(overrides?: CallOverrides): Promise<[string]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        removeMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        owner(overrides?: CallOverrides): Promise<[string]>;
         renounceOwnership(overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        routerV1(overrides?: CallOverrides): Promise<[string]>;
-        staking(overrides?: CallOverrides): Promise<[string]>;
-        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+        symbol(overrides?: CallOverrides): Promise<[string]>;
+        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<ContractTransaction>;
-        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber] & {
-            conversionRate: BigNumber;
-        }>;
-        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
-            lpToken: string;
-        }>;
-        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
-            lpToken: string;
-        }>;
     };
-    configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
+    addMinter(_minter: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
+    allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
+    approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+    burnFrom(_account: string, _value: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+    decimals(overrides?: CallOverrides): Promise<number>;
+    decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    ethVault(overrides?: CallOverrides): Promise<string>;
-    factoryV1(overrides?: CallOverrides): Promise<string>;
-    lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<string>;
-    lpToPool(lpToken: string, overrides?: CallOverrides): Promise<string>;
-    migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+    increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+    mint(_account: string, _amount: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+    minters(addr: string, overrides?: CallOverrides): Promise<boolean>;
+    name(overrides?: CallOverrides): Promise<string>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    removeMinter(_minter: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    owner(overrides?: CallOverrides): Promise<string>;
     renounceOwnership(overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    routerV1(overrides?: CallOverrides): Promise<string>;
-    staking(overrides?: CallOverrides): Promise<string>;
-    sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+    symbol(overrides?: CallOverrides): Promise<string>;
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+    transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
     transferOwnership(newOwner: string, overrides?: Overrides & {
         from?: string;
     }): Promise<ContractTransaction>;
-    v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-    v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
-    v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
     callStatic: {
-        configureLpToken(lpToken: string, enabled: boolean, overrides?: CallOverrides): Promise<void>;
-        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: CallOverrides): Promise<void>;
-        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
-        ethVault(overrides?: CallOverrides): Promise<string>;
-        factoryV1(overrides?: CallOverrides): Promise<string>;
-        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<string>;
-        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<string>;
-        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
-        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<string>;
+        addMinter(_minter: string, overrides?: CallOverrides): Promise<void>;
+        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
+        approve(spender: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+        burnFrom(_account: string, _value: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        decimals(overrides?: CallOverrides): Promise<number>;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        mint(_account: string, _amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        minters(addr: string, overrides?: CallOverrides): Promise<boolean>;
+        name(overrides?: CallOverrides): Promise<string>;
         owner(overrides?: CallOverrides): Promise<string>;
+        removeMinter(_minter: string, overrides?: CallOverrides): Promise<void>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
-        routerV1(overrides?: CallOverrides): Promise<string>;
-        staking(overrides?: CallOverrides): Promise<string>;
-        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        symbol(overrides?: CallOverrides): Promise<string>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transfer(to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
-        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
-        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<string>;
     };
     filters: {
-        "LpConfigured(address,address,address)"(lpToken?: string | null, pool?: string | null, asset?: null): LpConfiguredEventFilter;
-        LpConfigured(lpToken?: string | null, pool?: string | null, asset?: null): LpConfiguredEventFilter;
+        "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
+        Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
+        "MinterAdded(address)"(minter?: string | null): MinterAddedEventFilter;
+        MinterAdded(minter?: string | null): MinterAddedEventFilter;
+        "MinterRemoved(address)"(minter?: string | null): MinterRemovedEventFilter;
+        MinterRemoved(minter?: string | null): MinterRemovedEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$1;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter$1;
-        "TokenSwept(address,address,uint256)"(token?: string | null, receiver?: string | null, amount?: null): TokenSweptEventFilter;
-        TokenSwept(token?: string | null, receiver?: string | null, amount?: null): TokenSweptEventFilter;
-        "V1PoolConfigured(uint16,address,address)"(poolId?: BigNumberish | null, v1LpToken?: string | null, v2LpToken?: string | null): V1PoolConfiguredEventFilter;
-        V1PoolConfigured(poolId?: BigNumberish | null, v1LpToken?: string | null, v2LpToken?: string | null): V1PoolConfiguredEventFilter;
+        "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
+        Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
     };
     estimateGas: {
-        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
+        addMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
+        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
+        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+        burnFrom(_account: string, _value: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        decimals(overrides?: CallOverrides): Promise<BigNumber>;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        ethVault(overrides?: CallOverrides): Promise<BigNumber>;
-        factoryV1(overrides?: CallOverrides): Promise<BigNumber>;
-        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<BigNumber>;
-        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<BigNumber>;
-        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        mint(_account: string, _amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        minters(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        name(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        removeMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        owner(overrides?: CallOverrides): Promise<BigNumber>;
         renounceOwnership(overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        routerV1(overrides?: CallOverrides): Promise<BigNumber>;
-        staking(overrides?: CallOverrides): Promise<BigNumber>;
-        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+        symbol(overrides?: CallOverrides): Promise<BigNumber>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<BigNumber>;
-        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
     };
     populateTransaction: {
-        configureLpToken(lpToken: string, enabled: boolean, overrides?: Overrides & {
+        addMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        configureV1Pool(v1PoolId: BigNumberish, v2LpToken: string, overrides?: Overrides & {
+        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        depositAndStake(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        balanceOf(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        burnFrom(_account: string, _value: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        depositAndStakeWithPermit(lpToken: string, assetInAmount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        ethVault(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        factoryV1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        lpToAsset(lpToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        lpToPool(lpToken: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        migrateV1LpToV2Stake(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, overrides?: PayableOverrides & {
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        migrateV1LpToV2StakeWithPermit(poolId: BigNumberish, amount: BigNumberish, minStakeAmount: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        mint(_account: string, _amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        onWithdrawReceived(lpToken: string, from: string, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        minters(addr: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeMinter(_minter: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         renounceOwnership(overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        routerV1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        staking(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        sweep(token: string, receiver: string, amount: BigNumberish, overrides?: Overrides & {
+        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transfer(to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string;
         }): Promise<PopulatedTransaction>;
-        v1PidToConversionRate(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        v1PidToV1Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        v1PidToV2Lp(v1PoolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
     };
 }
 
@@ -2891,4 +2951,4 @@ interface StargateBase extends BaseContract {
     };
 }
 
-export { type FeeLibV1 as F, type GetContractTypeFromFactory as G, type MessagingBase as M, type OnEvent as O, type StargateMultiRewarder as S, type TypedEvent as T, type TypedEventFilter as a, type TypedListener as b, type OFTToken as c, type StargateStaking as d, type StargateZapperV1 as e, StargateBase as f, type FeeLibV1Interface as g, type MessagingBaseInterface as h, type OFTTokenInterface as i, type StargateMultiRewarderInterface as j, type StargateStakingInterface as k, type StargateZapperV1Interface as l, type StargateBaseInterface as m, type MinEthersFactory as n, type GetARGsTypeFromFactory as o };
+export { type FeeLibV1 as F, type GetContractTypeFromFactory as G, type MessagingBase as M, type OnEvent as O, type StargateMultiRewarder as S, type TypedEvent as T, type TypedEventFilter as a, type TypedListener as b, type StargateStaking as c, type StargateZapperV1 as d, type OFTTokenERC20 as e, StargateBase as f, type FeeLibV1Interface as g, type MessagingBaseInterface as h, type StargateMultiRewarderInterface as i, type StargateStakingInterface as j, type StargateZapperV1Interface as k, type OFTTokenERC20Interface as l, type StargateBaseInterface as m, type MinEthersFactory as n, type GetARGsTypeFromFactory as o };