@merkl/contracts 1.2.33 → 1.2.35

package/dist/src/SwapXGaugeV3Factory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SwapXGaugeV3Factory.js.map

package/dist/src/SwapXGaugeV3Factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwapXGaugeV3Factory.js","sourceRoot":"","sources":["../../src/SwapXGaugeV3Factory.ts"],"names":[],"mappings":""}

package/dist/src/SwapXV2Vault.d.ts

@@ -0,0 +1,634 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
+export interface SwapXV2VaultInterface extends utils.Interface {
+    functions: {
+        "DISTRIBUTION()": FunctionFragment;
+        "DURATION()": FunctionFragment;
+        "TOKEN()": FunctionFragment;
+        "TOKEN_WITHDRAWER()": FunctionFragment;
+        "VE()": FunctionFragment;
+        "activateEmergencyMode()": FunctionFragment;
+        "balanceOf(address)": FunctionFragment;
+        "claimFees()": FunctionFragment;
+        "deposit(uint256)": FunctionFragment;
+        "depositAll()": FunctionFragment;
+        "earned(address)": FunctionFragment;
+        "emergency()": FunctionFragment;
+        "emergencyWithdraw()": FunctionFragment;
+        "emergencyWithdrawAmount(uint256)": FunctionFragment;
+        "external_bribe()": FunctionFragment;
+        "gaugeRewarder()": FunctionFragment;
+        "getReward()": FunctionFragment;
+        "getReward(address)": FunctionFragment;
+        "internal_bribe()": FunctionFragment;
+        "isForPair()": FunctionFragment;
+        "lastTimeRewardApplicable()": FunctionFragment;
+        "lastUpdateTime()": FunctionFragment;
+        "notifyRewardAmount(address,uint256)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "periodFinish()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "rewardForDuration()": FunctionFragment;
+        "rewardPerToken()": FunctionFragment;
+        "rewardPerTokenStored()": FunctionFragment;
+        "rewardRate()": FunctionFragment;
+        "rewardToken()": FunctionFragment;
+        "rewards(address)": FunctionFragment;
+        "setDistribution(address)": FunctionFragment;
+        "setGaugeRewarder(address)": FunctionFragment;
+        "setInternalBribe(address)": FunctionFragment;
+        "stopEmergencyMode()": FunctionFragment;
+        "totalSupply()": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "userRewardPerTokenPaid(address)": FunctionFragment;
+        "withdraw(uint256)": FunctionFragment;
+        "withdrawAll()": FunctionFragment;
+        "withdrawAllAndHarvest()": FunctionFragment;
+        "withdrawExcess(address,uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "DISTRIBUTION" | "DURATION" | "TOKEN" | "TOKEN_WITHDRAWER" | "VE" | "activateEmergencyMode" | "balanceOf" | "claimFees" | "deposit" | "depositAll" | "earned" | "emergency" | "emergencyWithdraw" | "emergencyWithdrawAmount" | "external_bribe" | "gaugeRewarder" | "getReward()" | "getReward(address)" | "internal_bribe" | "isForPair" | "lastTimeRewardApplicable" | "lastUpdateTime" | "notifyRewardAmount" | "owner" | "periodFinish" | "renounceOwnership" | "rewardForDuration" | "rewardPerToken" | "rewardPerTokenStored" | "rewardRate" | "rewardToken" | "rewards" | "setDistribution" | "setGaugeRewarder" | "setInternalBribe" | "stopEmergencyMode" | "totalSupply" | "transferOwnership" | "userRewardPerTokenPaid" | "withdraw" | "withdrawAll" | "withdrawAllAndHarvest" | "withdrawExcess"): FunctionFragment;
+    encodeFunctionData(functionFragment: "DISTRIBUTION", values?: undefined): string;
+    encodeFunctionData(functionFragment: "DURATION", values?: undefined): string;
+    encodeFunctionData(functionFragment: "TOKEN", values?: undefined): string;
+    encodeFunctionData(functionFragment: "TOKEN_WITHDRAWER", values?: undefined): string;
+    encodeFunctionData(functionFragment: "VE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "activateEmergencyMode", values?: undefined): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "claimFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "depositAll", values?: undefined): string;
+    encodeFunctionData(functionFragment: "earned", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "emergency", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emergencyWithdraw", values?: undefined): string;
+    encodeFunctionData(functionFragment: "emergencyWithdrawAmount", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "external_bribe", values?: undefined): string;
+    encodeFunctionData(functionFragment: "gaugeRewarder", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getReward()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getReward(address)", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "internal_bribe", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isForPair", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastTimeRewardApplicable", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lastUpdateTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "notifyRewardAmount", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "periodFinish", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardForDuration", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardPerToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardPerTokenStored", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewardToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "rewards", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setDistribution", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setGaugeRewarder", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setInternalBribe", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stopEmergencyMode", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "userRewardPerTokenPaid", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "withdrawAll", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdrawAllAndHarvest", values?: undefined): string;
+    encodeFunctionData(functionFragment: "withdrawExcess", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    decodeFunctionResult(functionFragment: "DISTRIBUTION", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "DURATION", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "TOKEN", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "TOKEN_WITHDRAWER", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "VE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "activateEmergencyMode", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "earned", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergency", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdrawAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "external_bribe", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "gaugeRewarder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReward()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReward(address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "internal_bribe", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isForPair", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastTimeRewardApplicable", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastUpdateTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "notifyRewardAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "periodFinish", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardForDuration", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardPerToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardPerTokenStored", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewardToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setDistribution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setGaugeRewarder", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setInternalBribe", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stopEmergencyMode", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "userRewardPerTokenPaid", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawAllAndHarvest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawExcess", data: BytesLike): Result;
+    events: {
+        "ClaimFees(address,uint256,uint256)": EventFragment;
+        "Deposit(address,uint256)": EventFragment;
+        "EmergencyActivated(address,uint256)": EventFragment;
+        "EmergencyDeactivated(address,uint256)": EventFragment;
+        "Harvest(address,uint256)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+        "RewardAdded(uint256)": EventFragment;
+        "Withdraw(address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ClaimFees"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "EmergencyActivated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "EmergencyDeactivated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Harvest"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardAdded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
+}
+export interface ClaimFeesEventObject {
+    from: string;
+    claimed0: BigNumber;
+    claimed1: BigNumber;
+}
+export type ClaimFeesEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], ClaimFeesEventObject>;
+export type ClaimFeesEventFilter = TypedEventFilter<ClaimFeesEvent>;
+export interface DepositEventObject {
+    user: string;
+    amount: BigNumber;
+}
+export type DepositEvent = TypedEvent<[string, BigNumber], DepositEventObject>;
+export type DepositEventFilter = TypedEventFilter<DepositEvent>;
+export interface EmergencyActivatedEventObject {
+    gauge: string;
+    timestamp: BigNumber;
+}
+export type EmergencyActivatedEvent = TypedEvent<[
+    string,
+    BigNumber
+], EmergencyActivatedEventObject>;
+export type EmergencyActivatedEventFilter = TypedEventFilter<EmergencyActivatedEvent>;
+export interface EmergencyDeactivatedEventObject {
+    gauge: string;
+    timestamp: BigNumber;
+}
+export type EmergencyDeactivatedEvent = TypedEvent<[
+    string,
+    BigNumber
+], EmergencyDeactivatedEventObject>;
+export type EmergencyDeactivatedEventFilter = TypedEventFilter<EmergencyDeactivatedEvent>;
+export interface HarvestEventObject {
+    user: string;
+    reward: BigNumber;
+}
+export type HarvestEvent = TypedEvent<[string, BigNumber], HarvestEventObject>;
+export type HarvestEventFilter = TypedEventFilter<HarvestEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface RewardAddedEventObject {
+    reward: BigNumber;
+}
+export type RewardAddedEvent = TypedEvent<[BigNumber], RewardAddedEventObject>;
+export type RewardAddedEventFilter = TypedEventFilter<RewardAddedEvent>;
+export interface WithdrawEventObject {
+    user: string;
+    amount: BigNumber;
+}
+export type WithdrawEvent = TypedEvent<[
+    string,
+    BigNumber
+], WithdrawEventObject>;
+export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
+export interface SwapXV2Vault extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: SwapXV2VaultInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        DISTRIBUTION(overrides?: CallOverrides): Promise<[string]>;
+        DURATION(overrides?: CallOverrides): Promise<[BigNumber]>;
+        TOKEN(overrides?: CallOverrides): Promise<[string]>;
+        TOKEN_WITHDRAWER(overrides?: CallOverrides): Promise<[string]>;
+        VE(overrides?: CallOverrides): Promise<[string]>;
+        activateEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        claimFees(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        deposit(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        depositAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        emergency(overrides?: CallOverrides): Promise<[boolean]>;
+        emergencyWithdraw(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        emergencyWithdrawAmount(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        external_bribe(overrides?: CallOverrides): Promise<[string]>;
+        gaugeRewarder(overrides?: CallOverrides): Promise<[string]>;
+        "getReward()"(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        "getReward(address)"(_user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        internal_bribe(overrides?: CallOverrides): Promise<[string]>;
+        isForPair(overrides?: CallOverrides): Promise<[boolean]>;
+        lastTimeRewardApplicable(overrides?: CallOverrides): Promise<[BigNumber]>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<[BigNumber]>;
+        notifyRewardAmount(token: PromiseOrValue<string>, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        periodFinish(overrides?: CallOverrides): Promise<[BigNumber]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        rewardForDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardPerToken(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardRate(overrides?: CallOverrides): Promise<[BigNumber]>;
+        rewardToken(overrides?: CallOverrides): Promise<[string]>;
+        rewards(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        setDistribution(_distribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setGaugeRewarder(_gaugeRewarder: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setInternalBribe(_int: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        stopEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        userRewardPerTokenPaid(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        withdraw(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawAllAndHarvest(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawExcess(token: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    DISTRIBUTION(overrides?: CallOverrides): Promise<string>;
+    DURATION(overrides?: CallOverrides): Promise<BigNumber>;
+    TOKEN(overrides?: CallOverrides): Promise<string>;
+    TOKEN_WITHDRAWER(overrides?: CallOverrides): Promise<string>;
+    VE(overrides?: CallOverrides): Promise<string>;
+    activateEmergencyMode(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    claimFees(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    deposit(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    depositAll(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    emergency(overrides?: CallOverrides): Promise<boolean>;
+    emergencyWithdraw(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    emergencyWithdrawAmount(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    external_bribe(overrides?: CallOverrides): Promise<string>;
+    gaugeRewarder(overrides?: CallOverrides): Promise<string>;
+    "getReward()"(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    "getReward(address)"(_user: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    internal_bribe(overrides?: CallOverrides): Promise<string>;
+    isForPair(overrides?: CallOverrides): Promise<boolean>;
+    lastTimeRewardApplicable(overrides?: CallOverrides): Promise<BigNumber>;
+    lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+    notifyRewardAmount(token: PromiseOrValue<string>, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    rewardForDuration(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardPerToken(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+    rewardToken(overrides?: CallOverrides): Promise<string>;
+    rewards(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    setDistribution(_distribution: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setGaugeRewarder(_gaugeRewarder: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setInternalBribe(_int: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    stopEmergencyMode(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    userRewardPerTokenPaid(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    withdraw(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawAll(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawAllAndHarvest(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawExcess(token: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        DISTRIBUTION(overrides?: CallOverrides): Promise<string>;
+        DURATION(overrides?: CallOverrides): Promise<BigNumber>;
+        TOKEN(overrides?: CallOverrides): Promise<string>;
+        TOKEN_WITHDRAWER(overrides?: CallOverrides): Promise<string>;
+        VE(overrides?: CallOverrides): Promise<string>;
+        activateEmergencyMode(overrides?: CallOverrides): Promise<void>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        claimFees(overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            claimed0: BigNumber;
+            claimed1: BigNumber;
+        }>;
+        deposit(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        depositAll(overrides?: CallOverrides): Promise<void>;
+        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        emergency(overrides?: CallOverrides): Promise<boolean>;
+        emergencyWithdraw(overrides?: CallOverrides): Promise<void>;
+        emergencyWithdrawAmount(_amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        external_bribe(overrides?: CallOverrides): Promise<string>;
+        gaugeRewarder(overrides?: CallOverrides): Promise<string>;
+        "getReward()"(overrides?: CallOverrides): Promise<void>;
+        "getReward(address)"(_user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        internal_bribe(overrides?: CallOverrides): Promise<string>;
+        isForPair(overrides?: CallOverrides): Promise<boolean>;
+        lastTimeRewardApplicable(overrides?: CallOverrides): Promise<BigNumber>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+        notifyRewardAmount(token: PromiseOrValue<string>, reward: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        rewardForDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardPerToken(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardToken(overrides?: CallOverrides): Promise<string>;
+        rewards(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setDistribution(_distribution: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setGaugeRewarder(_gaugeRewarder: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setInternalBribe(_int: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        stopEmergencyMode(overrides?: CallOverrides): Promise<void>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        userRewardPerTokenPaid(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        withdraw(amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        withdrawAll(overrides?: CallOverrides): Promise<void>;
+        withdrawAllAndHarvest(overrides?: CallOverrides): Promise<void>;
+        withdrawExcess(token: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "ClaimFees(address,uint256,uint256)"(from?: PromiseOrValue<string> | null, claimed0?: null, claimed1?: null): ClaimFeesEventFilter;
+        ClaimFees(from?: PromiseOrValue<string> | null, claimed0?: null, claimed1?: null): ClaimFeesEventFilter;
+        "Deposit(address,uint256)"(user?: PromiseOrValue<string> | null, amount?: null): DepositEventFilter;
+        Deposit(user?: PromiseOrValue<string> | null, amount?: null): DepositEventFilter;
+        "EmergencyActivated(address,uint256)"(gauge?: PromiseOrValue<string> | null, timestamp?: null): EmergencyActivatedEventFilter;
+        EmergencyActivated(gauge?: PromiseOrValue<string> | null, timestamp?: null): EmergencyActivatedEventFilter;
+        "EmergencyDeactivated(address,uint256)"(gauge?: PromiseOrValue<string> | null, timestamp?: null): EmergencyDeactivatedEventFilter;
+        EmergencyDeactivated(gauge?: PromiseOrValue<string> | null, timestamp?: null): EmergencyDeactivatedEventFilter;
+        "Harvest(address,uint256)"(user?: PromiseOrValue<string> | null, reward?: null): HarvestEventFilter;
+        Harvest(user?: PromiseOrValue<string> | null, reward?: null): HarvestEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        "RewardAdded(uint256)"(reward?: null): RewardAddedEventFilter;
+        RewardAdded(reward?: null): RewardAddedEventFilter;
+        "Withdraw(address,uint256)"(user?: PromiseOrValue<string> | null, amount?: null): WithdrawEventFilter;
+        Withdraw(user?: PromiseOrValue<string> | null, amount?: null): WithdrawEventFilter;
+    };
+    estimateGas: {
+        DISTRIBUTION(overrides?: CallOverrides): Promise<BigNumber>;
+        DURATION(overrides?: CallOverrides): Promise<BigNumber>;
+        TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
+        TOKEN_WITHDRAWER(overrides?: CallOverrides): Promise<BigNumber>;
+        VE(overrides?: CallOverrides): Promise<BigNumber>;
+        activateEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        claimFees(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        deposit(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        depositAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        emergency(overrides?: CallOverrides): Promise<BigNumber>;
+        emergencyWithdraw(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        emergencyWithdrawAmount(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        external_bribe(overrides?: CallOverrides): Promise<BigNumber>;
+        gaugeRewarder(overrides?: CallOverrides): Promise<BigNumber>;
+        "getReward()"(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        "getReward(address)"(_user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        internal_bribe(overrides?: CallOverrides): Promise<BigNumber>;
+        isForPair(overrides?: CallOverrides): Promise<BigNumber>;
+        lastTimeRewardApplicable(overrides?: CallOverrides): Promise<BigNumber>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<BigNumber>;
+        notifyRewardAmount(token: PromiseOrValue<string>, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        periodFinish(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        rewardForDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardPerToken(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardRate(overrides?: CallOverrides): Promise<BigNumber>;
+        rewardToken(overrides?: CallOverrides): Promise<BigNumber>;
+        rewards(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setDistribution(_distribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setGaugeRewarder(_gaugeRewarder: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setInternalBribe(_int: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        stopEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        userRewardPerTokenPaid(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        withdraw(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawAllAndHarvest(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawExcess(token: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        DISTRIBUTION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        DURATION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        TOKEN_WITHDRAWER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        VE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        activateEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        claimFees(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        deposit(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        depositAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        earned(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        emergency(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        emergencyWithdraw(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        emergencyWithdrawAmount(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        external_bribe(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        gaugeRewarder(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "getReward()"(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        "getReward(address)"(_user: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        internal_bribe(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isForPair(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lastTimeRewardApplicable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lastUpdateTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        notifyRewardAmount(token: PromiseOrValue<string>, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        periodFinish(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        rewardForDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardPerToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardPerTokenStored(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardRate(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewardToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        rewards(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setDistribution(_distribution: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setGaugeRewarder(_gaugeRewarder: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setInternalBribe(_int: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        stopEmergencyMode(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        userRewardPerTokenPaid(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        withdraw(amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawAll(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawAllAndHarvest(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawExcess(token: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/src/SwapXV2Vault.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SwapXV2Vault.js.map

package/dist/src/SwapXV2Vault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwapXV2Vault.js","sourceRoot":"","sources":["../../src/SwapXV2Vault.ts"],"names":[],"mappings":""}