@ape.swap/bonds-sdk 1.0.270 → 1.0.271

package/dist/config/abi/types/v3/v3-staker/artifacts/contracts/interfaces/IUniswapV3Staker.d.ts

@@ -0,0 +1,465 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../../../common";
+export declare namespace IUniswapV3Staker {
+    type IncentiveKeyStruct = {
+        rewardToken: PromiseOrValue<string>;
+        pool: PromiseOrValue<string>;
+        startTime: PromiseOrValue<BigNumberish>;
+        endTime: PromiseOrValue<BigNumberish>;
+        refundee: PromiseOrValue<string>;
+    };
+    type IncentiveKeyStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        string
+    ] & {
+        rewardToken: string;
+        pool: string;
+        startTime: BigNumber;
+        endTime: BigNumber;
+        refundee: string;
+    };
+}
+export interface IUniswapV3StakerInterface extends utils.Interface {
+    functions: {
+        "claimReward(address,address,uint256)": FunctionFragment;
+        "createIncentive((address,address,uint256,uint256,address),uint256)": FunctionFragment;
+        "deposits(uint256)": FunctionFragment;
+        "endIncentive((address,address,uint256,uint256,address))": FunctionFragment;
+        "factory()": FunctionFragment;
+        "getRewardInfo((address,address,uint256,uint256,address),uint256)": FunctionFragment;
+        "incentives(bytes32)": FunctionFragment;
+        "maxIncentiveDuration()": FunctionFragment;
+        "maxIncentiveStartLeadTime()": FunctionFragment;
+        "multicall(bytes[])": FunctionFragment;
+        "nonfungiblePositionManager()": FunctionFragment;
+        "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
+        "rewards(address,address)": FunctionFragment;
+        "stakeToken((address,address,uint256,uint256,address),uint256)": FunctionFragment;
+        "stakes(uint256,bytes32)": FunctionFragment;
+        "transferDeposit(uint256,address)": FunctionFragment;
+        "unstakeToken((address,address,uint256,uint256,address),uint256)": FunctionFragment;
+        "withdrawToken(uint256,address,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claimReward" | "createIncentive" | "deposits" | "endIncentive" | "factory" | "getRewardInfo" | "incentives" | "maxIncentiveDuration" | "maxIncentiveStartLeadTime" | "multicall" | "nonfungiblePositionManager" | "onERC721Received" | "rewards" | "stakeToken" | "stakes" | "transferDeposit" | "unstakeToken" | "withdrawToken"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claimReward", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "createIncentive", values: [IUniswapV3Staker.IncentiveKeyStruct, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "deposits", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "endIncentive", values: [IUniswapV3Staker.IncentiveKeyStruct]): string;
+    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getRewardInfo", values: [IUniswapV3Staker.IncentiveKeyStruct, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "incentives", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "maxIncentiveDuration", values?: undefined): string;
+    encodeFunctionData(functionFragment: "maxIncentiveStartLeadTime", values?: undefined): string;
+    encodeFunctionData(functionFragment: "multicall", values: [PromiseOrValue<BytesLike>[]]): string;
+    encodeFunctionData(functionFragment: "nonfungiblePositionManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "onERC721Received", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    encodeFunctionData(functionFragment: "rewards", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeToken", values: [IUniswapV3Staker.IncentiveKeyStruct, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "stakes", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "transferDeposit", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "unstakeToken", values: [IUniswapV3Staker.IncentiveKeyStruct, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "withdrawToken", values: [
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>
+    ]): string;
+    decodeFunctionResult(functionFragment: "claimReward", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createIncentive", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposits", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "endIncentive", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRewardInfo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "incentives", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maxIncentiveDuration", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maxIncentiveStartLeadTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonfungiblePositionManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onERC721Received", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unstakeToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawToken", data: BytesLike): Result;
+    events: {
+        "DepositTransferred(uint256,address,address)": EventFragment;
+        "IncentiveCreated(address,address,uint256,uint256,address,uint256)": EventFragment;
+        "IncentiveEnded(bytes32,uint256)": EventFragment;
+        "RewardClaimed(address,uint256)": EventFragment;
+        "TokenStaked(uint256,bytes32,uint128)": EventFragment;
+        "TokenUnstaked(uint256,bytes32)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "DepositTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "IncentiveCreated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "IncentiveEnded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardClaimed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TokenStaked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TokenUnstaked"): EventFragment;
+}
+export interface DepositTransferredEventObject {
+    tokenId: BigNumber;
+    oldOwner: string;
+    newOwner: string;
+}
+export type DepositTransferredEvent = TypedEvent<[
+    BigNumber,
+    string,
+    string
+], DepositTransferredEventObject>;
+export type DepositTransferredEventFilter = TypedEventFilter<DepositTransferredEvent>;
+export interface IncentiveCreatedEventObject {
+    rewardToken: string;
+    pool: string;
+    startTime: BigNumber;
+    endTime: BigNumber;
+    refundee: string;
+    reward: BigNumber;
+}
+export type IncentiveCreatedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    string,
+    BigNumber
+], IncentiveCreatedEventObject>;
+export type IncentiveCreatedEventFilter = TypedEventFilter<IncentiveCreatedEvent>;
+export interface IncentiveEndedEventObject {
+    incentiveId: string;
+    refund: BigNumber;
+}
+export type IncentiveEndedEvent = TypedEvent<[
+    string,
+    BigNumber
+], IncentiveEndedEventObject>;
+export type IncentiveEndedEventFilter = TypedEventFilter<IncentiveEndedEvent>;
+export interface RewardClaimedEventObject {
+    to: string;
+    reward: BigNumber;
+}
+export type RewardClaimedEvent = TypedEvent<[
+    string,
+    BigNumber
+], RewardClaimedEventObject>;
+export type RewardClaimedEventFilter = TypedEventFilter<RewardClaimedEvent>;
+export interface TokenStakedEventObject {
+    tokenId: BigNumber;
+    incentiveId: string;
+    liquidity: BigNumber;
+}
+export type TokenStakedEvent = TypedEvent<[
+    BigNumber,
+    string,
+    BigNumber
+], TokenStakedEventObject>;
+export type TokenStakedEventFilter = TypedEventFilter<TokenStakedEvent>;
+export interface TokenUnstakedEventObject {
+    tokenId: BigNumber;
+    incentiveId: string;
+}
+export type TokenUnstakedEvent = TypedEvent<[
+    BigNumber,
+    string
+], TokenUnstakedEventObject>;
+export type TokenUnstakedEventFilter = TypedEventFilter<TokenUnstakedEvent>;
+export interface IUniswapV3Staker extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IUniswapV3StakerInterface;
+    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: {
+        claimReward(rewardToken: PromiseOrValue<string>, to: PromiseOrValue<string>, amountRequested: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        deposits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            string,
+            number,
+            number,
+            number
+        ] & {
+            owner: string;
+            numberOfStakes: number;
+            tickLower: number;
+            tickUpper: number;
+        }>;
+        endIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        factory(overrides?: CallOverrides): Promise<[string]>;
+        getRewardInfo(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        incentives(incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            totalRewardUnclaimed: BigNumber;
+            totalSecondsClaimedX128: BigNumber;
+            numberOfStakes: BigNumber;
+        }>;
+        maxIncentiveDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
+        maxIncentiveStartLeadTime(overrides?: CallOverrides): Promise<[BigNumber]>;
+        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        nonfungiblePositionManager(overrides?: CallOverrides): Promise<[string]>;
+        onERC721Received(operator: PromiseOrValue<string>, from: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        rewards(rewardToken: PromiseOrValue<string>, owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber] & {
+            rewardsOwed: BigNumber;
+        }>;
+        stakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        stakes(tokenId: PromiseOrValue<BigNumberish>, incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            secondsPerLiquidityInsideInitialX128: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        transferDeposit(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        unstakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawToken(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    claimReward(rewardToken: PromiseOrValue<string>, to: PromiseOrValue<string>, amountRequested: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    deposits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+        string,
+        number,
+        number,
+        number
+    ] & {
+        owner: string;
+        numberOfStakes: number;
+        tickLower: number;
+        tickUpper: number;
+    }>;
+    endIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    factory(overrides?: CallOverrides): Promise<string>;
+    getRewardInfo(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    incentives(incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        totalRewardUnclaimed: BigNumber;
+        totalSecondsClaimedX128: BigNumber;
+        numberOfStakes: BigNumber;
+    }>;
+    maxIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+    maxIncentiveStartLeadTime(overrides?: CallOverrides): Promise<BigNumber>;
+    multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    nonfungiblePositionManager(overrides?: CallOverrides): Promise<string>;
+    onERC721Received(operator: PromiseOrValue<string>, from: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    rewards(rewardToken: PromiseOrValue<string>, owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    stakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    stakes(tokenId: PromiseOrValue<BigNumberish>, incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber
+    ] & {
+        secondsPerLiquidityInsideInitialX128: BigNumber;
+        liquidity: BigNumber;
+    }>;
+    transferDeposit(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    unstakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawToken(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        claimReward(rewardToken: PromiseOrValue<string>, to: PromiseOrValue<string>, amountRequested: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        createIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, reward: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        deposits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            string,
+            number,
+            number,
+            number
+        ] & {
+            owner: string;
+            numberOfStakes: number;
+            tickLower: number;
+            tickUpper: number;
+        }>;
+        endIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        factory(overrides?: CallOverrides): Promise<string>;
+        getRewardInfo(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            reward: BigNumber;
+            secondsInsideX128: BigNumber;
+        }>;
+        incentives(incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            totalRewardUnclaimed: BigNumber;
+            totalSecondsClaimedX128: BigNumber;
+            numberOfStakes: BigNumber;
+        }>;
+        maxIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        maxIncentiveStartLeadTime(overrides?: CallOverrides): Promise<BigNumber>;
+        multicall(data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
+        nonfungiblePositionManager(overrides?: CallOverrides): Promise<string>;
+        onERC721Received(operator: PromiseOrValue<string>, from: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
+        rewards(rewardToken: PromiseOrValue<string>, owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        stakes(tokenId: PromiseOrValue<BigNumberish>, incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            secondsPerLiquidityInsideInitialX128: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        transferDeposit(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        unstakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        withdrawToken(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "DepositTransferred(uint256,address,address)"(tokenId?: PromiseOrValue<BigNumberish> | null, oldOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): DepositTransferredEventFilter;
+        DepositTransferred(tokenId?: PromiseOrValue<BigNumberish> | null, oldOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): DepositTransferredEventFilter;
+        "IncentiveCreated(address,address,uint256,uint256,address,uint256)"(rewardToken?: PromiseOrValue<string> | null, pool?: PromiseOrValue<string> | null, startTime?: null, endTime?: null, refundee?: null, reward?: null): IncentiveCreatedEventFilter;
+        IncentiveCreated(rewardToken?: PromiseOrValue<string> | null, pool?: PromiseOrValue<string> | null, startTime?: null, endTime?: null, refundee?: null, reward?: null): IncentiveCreatedEventFilter;
+        "IncentiveEnded(bytes32,uint256)"(incentiveId?: PromiseOrValue<BytesLike> | null, refund?: null): IncentiveEndedEventFilter;
+        IncentiveEnded(incentiveId?: PromiseOrValue<BytesLike> | null, refund?: null): IncentiveEndedEventFilter;
+        "RewardClaimed(address,uint256)"(to?: PromiseOrValue<string> | null, reward?: null): RewardClaimedEventFilter;
+        RewardClaimed(to?: PromiseOrValue<string> | null, reward?: null): RewardClaimedEventFilter;
+        "TokenStaked(uint256,bytes32,uint128)"(tokenId?: PromiseOrValue<BigNumberish> | null, incentiveId?: PromiseOrValue<BytesLike> | null, liquidity?: null): TokenStakedEventFilter;
+        TokenStaked(tokenId?: PromiseOrValue<BigNumberish> | null, incentiveId?: PromiseOrValue<BytesLike> | null, liquidity?: null): TokenStakedEventFilter;
+        "TokenUnstaked(uint256,bytes32)"(tokenId?: PromiseOrValue<BigNumberish> | null, incentiveId?: PromiseOrValue<BytesLike> | null): TokenUnstakedEventFilter;
+        TokenUnstaked(tokenId?: PromiseOrValue<BigNumberish> | null, incentiveId?: PromiseOrValue<BytesLike> | null): TokenUnstakedEventFilter;
+    };
+    estimateGas: {
+        claimReward(rewardToken: PromiseOrValue<string>, to: PromiseOrValue<string>, amountRequested: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        deposits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        endIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        factory(overrides?: CallOverrides): Promise<BigNumber>;
+        getRewardInfo(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        incentives(incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        maxIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+        maxIncentiveStartLeadTime(overrides?: CallOverrides): Promise<BigNumber>;
+        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        nonfungiblePositionManager(overrides?: CallOverrides): Promise<BigNumber>;
+        onERC721Received(operator: PromiseOrValue<string>, from: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        rewards(rewardToken: PromiseOrValue<string>, owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        stakes(tokenId: PromiseOrValue<BigNumberish>, incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        transferDeposit(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        unstakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawToken(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claimReward(rewardToken: PromiseOrValue<string>, to: PromiseOrValue<string>, amountRequested: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, reward: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        deposits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        endIncentive(key: IUniswapV3Staker.IncentiveKeyStruct, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRewardInfo(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        incentives(incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        maxIncentiveDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        maxIncentiveStartLeadTime(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        multicall(data: PromiseOrValue<BytesLike>[], overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        nonfungiblePositionManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        onERC721Received(operator: PromiseOrValue<string>, from: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        rewards(rewardToken: PromiseOrValue<string>, owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        stakes(tokenId: PromiseOrValue<BigNumberish>, incentiveId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferDeposit(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        unstakeToken(key: IUniswapV3Staker.IncentiveKeyStruct, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawToken(tokenId: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/config/abi/types/v3/v3-staker/artifacts/contracts/interfaces/IUniswapV3Staker.js

@@ -0,0 +1 @@
+export {};

package/dist/config/abi/types/v3/v3-staker/artifacts/contracts/interfaces/index.d.ts

@@ -0,0 +1 @@
+export type { IUniswapV3Staker } from "./IUniswapV3Staker";

package/dist/config/abi/types/v3/v3-staker/artifacts/contracts/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/config/abi/types/v3/v3-staker/artifacts/index.d.ts

@@ -0,0 +1,2 @@
+import type * as contracts from "./contracts";
+export type { contracts };

package/dist/config/abi/types/v3/v3-staker/artifacts/index.js

@@ -0,0 +1 @@
+export {};

package/dist/config/abi/types/v3/v3-staker/index.d.ts

@@ -0,0 +1,2 @@
+import type * as artifacts from "./artifacts";
+export type { artifacts };

package/dist/config/abi/types/v3/v3-staker/index.js

@@ -0,0 +1 @@
+export {};

package/dist/config/constants/addresses.d.ts

@@ -15,4 +15,6 @@ export declare const LENS_CONTRACT: AddressMap;
 export declare const LOCK_VEABOND_ADDRESSES: AddressMap;
 export declare const veABOND_ADDRESSES: AddressMap;
 export declare const FEVEABOND_CLAIM_ADDRESSES: AddressMap;
+export declare const CEX_BILL_ADDRESS: string;
+export declare const ACF_TO_ABOND: string;
 export {};

package/dist/config/constants/addresses.js

@@ -68,6 +68,7 @@ export var MULTICALL = (_g = {},
     _g[ChainId.LINEA] = '0x0a11a37Eff2e32Fd532F6e1C30e77B7DCBeF2de1',
     _g[ChainId.LIGHTLINK] = '0xD2f432d6260Ce513eA499Bc30a720e78ad26B4A1',
     _g[ChainId.BASE] = '0xce512f490Bf09C4544A12a7264750B28FbE9AD76',
+    _g[ChainId.IOTA] = '0x048a5E910E44021A00c3769872Ff3804c2241deD',
     _g);
 export var MULTICALL_V2 = (_h = {},
     _h[SupportedChainId.BSC] = '0x38ce767d81de3940CFa5020B55af1A400ED4F657',
@@ -110,3 +111,5 @@ export var veABOND_ADDRESSES = (_m = {},
 export var FEVEABOND_CLAIM_ADDRESSES = (_o = {},
     _o[SupportedChainId.BSC] = '0x57b3e16f98fc83E39C6E53Bab4F8909c67F17A80',
     _o);
+export var CEX_BILL_ADDRESS = '0x6D7637683eaD28F775F56506602191fdE417fF60';
+export var ACF_TO_ABOND = '0xEce2b9C3704632Ce760271B0b84E3A4A698Ca962';

package/dist/contexts/RefreshContext.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+declare const RefreshContext: React.Context<{
+    slow: number;
+    fast: number;
+    veryFast: number;
+}>;
+declare const RefreshContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export { RefreshContext, RefreshContextProvider };

package/dist/contexts/RefreshContext.js

@@ -0,0 +1,89 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "theme-ui/jsx-runtime";
+import React, { useState, useEffect } from 'react';
+var VERY_FAST_INTERVAL = 5000;
+var FAST_INTERVAL = 15000;
+var SLOW_INTERVAL = 60000;
+var RefreshContext = React.createContext({ slow: 0, fast: 0, veryFast: 0 });
+// This context maintain 2 counters that can be used as a dependencies on other hooks to force a periodic refresh
+var RefreshContextProvider = function (_a) {
+    var children = _a.children;
+    var _b = useState(0), slow = _b[0], setSlow = _b[1];
+    var _c = useState(0), fast = _c[0], setFast = _c[1];
+    var _d = useState(0), veryFast = _d[0], setVeryFast = _d[1];
+    useEffect(function () {
+        var interval = setInterval(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                setVeryFast(function (prev) { return prev + 1; });
+                return [2 /*return*/];
+            });
+        }); }, VERY_FAST_INTERVAL);
+        return function () { return clearInterval(interval); };
+    }, []);
+    useEffect(function () {
+        var interval = setInterval(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                setFast(function (prev) { return prev + 1; });
+                return [2 /*return*/];
+            });
+        }); }, FAST_INTERVAL);
+        return function () { return clearInterval(interval); };
+    }, []);
+    useEffect(function () {
+        var interval = setInterval(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                setSlow(function (prev) { return prev + 1; });
+                return [2 /*return*/];
+            });
+        }); }, SLOW_INTERVAL);
+        return function () { return clearInterval(interval); };
+    }, []);
+    return _jsx(RefreshContext.Provider, __assign({ value: { slow: slow, fast: fast, veryFast: veryFast } }, { children: children }));
+};
+export { RefreshContext, RefreshContextProvider };

package/dist/enum/apeswaplists.d.ts

@@ -43,3 +43,11 @@ export declare enum LiquidityDex {
     SmarDex = "SmarDex",
     MagicSea = "MagicSea"
 }
+export declare enum BillVersion {
+    V1 = "V1",
+    V2 = "V2",
+    FixedPrice = "FixedPrice",
+    V3 = "V3",
+    TieredSale = "TieredSale",
+    FlashTieredSale = "FlashTieredSale"
+}

package/dist/enum/apeswaplists.js

@@ -46,3 +46,12 @@ export var LiquidityDex;
     LiquidityDex["SmarDex"] = "SmarDex";
     LiquidityDex["MagicSea"] = "MagicSea";
 })(LiquidityDex || (LiquidityDex = {}));
+export var BillVersion;
+(function (BillVersion) {
+    BillVersion["V1"] = "V1";
+    BillVersion["V2"] = "V2";
+    BillVersion["FixedPrice"] = "FixedPrice";
+    BillVersion["V3"] = "V3";
+    BillVersion["TieredSale"] = "TieredSale";
+    BillVersion["FlashTieredSale"] = "FlashTieredSale";
+})(BillVersion || (BillVersion = {}));

package/dist/hooks/useRefresh.d.ts

@@ -0,0 +1,6 @@
+declare const useRefresh: () => {
+    veryFastRefresh: number;
+    fastRefresh: number;
+    slowRefresh: number;
+};
+export default useRefresh;