import * as viem from 'viem';
import { Address, PublicClient, WalletClient, GetLogsReturnType, Abi, TypedDataDomain } from 'viem';
import { ReactNode } from 'react';

interface CoingeckoTokenPrices {
    [id: string]: {
        [currency: string]: number;
    };
}
interface CoingeckoExchangeRates {
    [id: string]: {
        name: string;
        unit: string;
        value: number;
        type: 'crypto' | 'fiat' | 'commodity';
    };
}
interface CoingeckoTokenData {
    id: string;
    symbol: string;
    name: string;
    asset_platform_id: string;
    platforms: Record<string, string>;
    detail_platforms: Record<string, {
        decimal_place: number;
        contract_address: string;
    }>;
    categories: string[];
    links: Record<string, string | string[] | Record<string, string[]>>;
    image: {
        thumb: string;
        small: string;
        large: string;
    };
    contract_address: string;
    market_cap_rank: number;
    coingecko_rank: number;
    coingecko_score: number;
    developer_score: number;
    community_score: number;
    liquidity_score: number;
    public_interest_score: number;
    market_data: CoingeckoTokenMarketData;
    last_updated: string;
}
interface CoingeckoTokenMarketData {
    current_price: Record<string, number>;
    total_value_locked: Record<string, number>;
    mcap_to_tvl_ratio: number;
    fdv_to_tvl_ratio: number;
    ath: Record<string, number>;
    ath_change_percentage: Record<string, number>;
    ath_date: Record<string, string>;
    atl: Record<string, number>;
    atl_change_percentage: Record<string, number>;
    atl_date: Record<string, string>;
    market_cap: Record<string, number>;
    market_cap_rank: number;
    fully_diluted_valuation: Record<string, number>;
    total_volume: Record<string, number>;
    high_24h: Record<string, number>;
    low_24h: Record<string, number>;
    price_change_24h: number;
    price_change_percentage_24h: number;
    price_change_percentage_7d: number;
    price_change_percentage_14d: number;
    price_change_percentage_30d: number;
    price_change_percentage_60d: number;
    price_change_percentage_200d: number;
    price_change_percentage_1y: number;
    market_cap_change_24h: number;
    market_cap_change_percentage_24h: number;
    total_supply: number;
    max_supply: number | undefined;
    circulating_supply: number;
    last_updated: string;
}

interface Version {
    readonly major: number;
    readonly minor: number;
    readonly patch: number;
}
interface Tags {
    readonly [tagId: string]: {
        readonly name: string;
        readonly description: string;
    };
}
interface ABIIdentifier {
    readonly version: Version;
    readonly type: string;
}
interface ContractIdentifier {
    readonly chainId: number;
    readonly address: string;
}
interface Contract extends ABIIdentifier, ContractIdentifier {
    readonly abi: object[];
    readonly tags?: string[];
    readonly extensions?: {
        readonly [key: string]: any;
    };
}
interface ContractList {
    name: string;
    version: Version;
    tags: Tags;
    contracts: Contract[];
}

type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;

interface ERC2612PermitMessage {
    owner: string;
    spender: string;
    value: number | string;
    nonce: number | string;
    deadline: number | string;
}
interface EIP2612SignatureTuple {
    deadline: number;
    v: number;
    r: string;
    s: string;
}

interface FrameRequest {
    untrustedData: FrameData;
    trustedData: {
        messageBytes: string;
    };
}
interface FrameData {
    fid: number;
    url: string;
    messageHash: string;
    timestamp: number;
    network: number;
    buttonIndex: number;
    castId: {
        fid: number;
        hash: string;
    };
    inputText?: string;
    transactionId?: string;
    state?: string;
}
type FrameButton = {
    content: string;
    action?: 'post';
} | {
    content: string;
    action: 'post_redirect';
} | {
    content: string;
    action: 'link';
    target: string;
} | {
    content: string;
    action: 'mint';
    target: string;
} | {
    content: string;
    action: 'tx';
    target: string;
    callback: string;
};

interface GasCostEstimates {
    totalGasWei: bigint;
    totalGasEth: number;
}

type Intl$1<T = any> = (key: T, data?: {
    [id: string]: number | string;
}) => string;
interface RichIntl<T = any> extends Intl$1<T> {
    rich: (key: T, data: {
        [id: string]: (chunks: ReactNode) => ReactNode;
    }) => ReactNode;
}

interface PairCreateInfo {
    chainId: number;
    source: `0x${string}`;
    tokenIn: `0x${string}`;
    tokenOut: `0x${string}`;
    targetAuctionPeriod: number;
    targetAuctionPrice: bigint;
    smoothingFactor: number;
}

type Mutable<T> = {
    -readonly [P in keyof T]: T[P];
};

interface PrizeInfo {
    amount: {
        current: bigint;
        estimated: bigint;
    };
    dailyFrequency: number;
}
interface DrawWithTimestamps {
    id: number;
    openedAt: number;
    closedAt: number;
    finalizedAt: number;
}
type DrawStatus = 'open' | 'closed' | 'awarded' | 'finalized';
interface Prize {
    chainId: number;
    drawId: number;
    vault: `0x${string}`;
    winner: `0x${string}`;
    tier: number;
    prizeIndex: number;
    amount?: bigint;
}
interface Win {
    chainId: number;
    drawId: number;
    vault: `0x${string}`;
    payout: bigint;
    txHash: `0x${string}`;
    timestamp: number;
}

interface PromotionInfo {
    creator: `0x${string}`;
    startTimestamp: bigint;
    numberOfEpochs: number;
    vault: `0x${string}`;
    epochDuration: number;
    createdAt: number;
    token: `0x${string}`;
    tokensPerEpoch: bigint;
    rewardsUnclaimed: bigint;
}
interface PartialPromotionInfo {
    creator?: `0x${string}`;
    startTimestamp: bigint;
    numberOfEpochs?: number;
    vault: `0x${string}`;
    epochDuration: number;
    createdAt?: number;
    createdAtBlockNumber: bigint;
    token: `0x${string}`;
    tokensPerEpoch: bigint;
    rewardsUnclaimed?: bigint;
}
interface PoolWidePromotionInfo {
    creator: `0x${string}`;
    startTimestamp: bigint;
    numberOfEpochs: number;
    epochDuration: number;
    createdAt: number;
    token: `0x${string}`;
    tokensPerEpoch: bigint;
    rewardsUnclaimed: bigint;
}
interface PartialPoolWidePromotionInfo extends PartialPromotionInfo {
    vaultTokensPerEpoch: bigint[];
}

interface SubgraphDraw {
    id: number;
    prizeClaims: {
        id: string;
        winner: `0x${string}`;
        recipient: `0x${string}`;
        vaultAddress: `0x${string}`;
        tier: number;
        prizeIndex: number;
        payout: bigint;
        claimReward: bigint;
        claimRewardRecipient: `0x${string}`;
        timestamp: number;
        txHash: `0x${string}`;
    }[];
}
interface SubgraphPrize {
    id: string;
    drawId: number;
    vaultAddress: `0x${string}`;
    tier: number;
    prizeIndex: number;
    payout: bigint;
    claimReward: bigint;
    claimRewardRecipient: `0x${string}`;
    timestamp: number;
    txHash: `0x${string}`;
}
interface SubgraphObservation {
    balance: bigint;
    delegateBalance: bigint;
    timestamp: number;
    isNew: boolean;
}

declare enum TimeUnit {
    second = "second",
    minute = "minute",
    hour = "hour",
    day = "day",
    week = "week",
    month = "month",
    year = "year"
}

interface Token {
    chainId: number;
    address: `0x${string}`;
    symbol: string;
    name: string;
    decimals: number;
}
interface TokenWithPrice extends Token {
    price?: number;
}
interface TokenWithLogo extends Token {
    logoURI: string;
}
interface TokenWithSupply extends Token {
    totalSupply: bigint;
}
interface TokenWithAmount extends Token {
    amount: bigint;
}

interface TxOverrides {
    maxFeePerGas?: bigint;
    maxPriorityFeePerGas?: bigint;
    nonce?: number;
}

/**
 * Vault list interface, compatible with Uniswap's token lists (https://tokenlists.org/)
 */
interface VaultList {
    readonly name: string;
    readonly version: Version;
    readonly timestamp: string;
    readonly tokens: VaultInfo[];
    readonly keywords?: string[];
    readonly tags?: VaultListTags;
    readonly logoURI?: string;
}
interface VaultInfo {
    readonly chainId: number;
    readonly address: `0x${string}`;
    readonly name?: string;
    readonly decimals?: number;
    readonly symbol?: string;
    readonly extensions?: VaultExtensions;
    readonly tags?: string[];
    readonly logoURI?: string;
}
interface VaultExtensions {
    readonly underlyingAsset?: {
        readonly address?: `0x${string}`;
        readonly symbol?: string;
        readonly name?: string;
        readonly logoURI?: string;
    };
    readonly yieldSource?: {
        readonly name?: string;
        readonly appURI?: string;
    };
    readonly lp?: {
        readonly appURI?: string;
    };
    readonly [key: string]: {
        [key: string]: {
            [key: string]: VaultExtensionValue;
        } | VaultExtensionValue;
    } | VaultExtensionValue;
}
type VaultExtensionValue = string | number | boolean | null | undefined;
interface VaultListTags {
    readonly [tagId: string]: {
        readonly name: string;
        readonly description: string;
    };
}
type MutableVaultList = Omit<Mutable<VaultList>, 'tokens'> & {
    tokens: MutableVaultInfo[];
};
type MutableVaultInfo = Omit<Mutable<VaultInfo>, 'extensions'> & {
    extensions?: MutableVaultExtensions;
};
type MutableVaultExtensions = Omit<Mutable<VaultExtensions>, 'underlyingAsset'> & {
    underlyingAsset?: Mutable<VaultExtensions['underlyingAsset']>;
};
interface VaultDeployInfo {
    chainId: number;
    tokenAddress?: `0x${string}`;
    name: string;
    symbol: string;
    yieldSourceName?: string;
    yieldSourceAddress: `0x${string}`;
    prizePool: `0x${string}`;
    vaultFactory?: `0x${string}`;
    claimer: `0x${string}`;
    feeRecipient: `0x${string}`;
    feePercentage: number;
    owner: `0x${string}`;
    yieldBuffer: bigint;
}

/**
 * This class provides read and write functions to interact with a prize pool
 */
declare class PrizePool {
    chainId: number;
    address: Address;
    publicClient: PublicClient;
    readonly id: string;
    walletClient: WalletClient | undefined;
    prizeTokenAddress: Address | undefined;
    drawManagerAddress: Address | undefined;
    twabControllerAddress: Address | undefined;
    drawPeriodInSeconds: number | undefined;
    drawAuctionDurationInSeconds: number | undefined;
    tierShares: number | undefined;
    reserveShares: number | undefined;
    tierLiquidityUtilizationRate: bigint | undefined;
    grandPrizePeriodDraws: number | undefined;
    /**
     * Creates an instance of a Prize Pool with a given public and optional wallet client
     *
     * NOTE: If initialized without a wallet Viem client, write functions will not be available
     * @param chainId the prize pool's chain ID
     * @param address the prize pool's address
     * @param publicClient a public Viem client for the network the prize pool is deployed on
     * @param options optional parameters (including wallet client)
     */
    constructor(chainId: number, address: Address, publicClient: PublicClient, options?: {
        walletClient?: WalletClient;
        prizeTokenAddress?: Address;
        drawManagerAddress?: Address;
        twabControllerAddress?: Address;
        drawPeriodInSeconds?: number;
        drawAuctionDurationInSeconds?: number;
        tierShares?: number;
        reserveShares?: number;
        tierLiquidityUtilizationRate?: bigint;
        grandPrizePeriodDraws?: number;
    });
    /**
     * Returns the address of the token awarded by the prize pool
     * @returns
     */
    getPrizeTokenAddress(): Promise<Address>;
    /**
     * Returns the address of prize pool's draw manager
     * @returns
     */
    getDrawManagerAddress(): Promise<Address>;
    /**
     * Returns the address of the prize pool's TWAB controller
     * @returns
     */
    getTwabControllerAddress(): Promise<Address>;
    /**
     * Returns basic data about the token awarded by the prize pool
     * @returns
     */
    getPrizeTokenData(): Promise<TokenWithSupply>;
    /**
     * Returns the duration of a draw in seconds
     * @returns
     */
    getDrawPeriodInSeconds(): Promise<number>;
    /**
     * Returns the duration of a draw auction in seconds
     * @returns
     */
    getDrawAuctionDurationInSeconds(): Promise<number>;
    /**
     * Returns the number of shares allocated to each prize tier
     * @returns
     */
    getTierShares(): Promise<number>;
    /**
     * Returns the number of shares allocated to the reserve
     * @returns
     */
    getReserveShares(): Promise<number>;
    /**
     * Returns the number of prize tiers in the prize pool
     *
     * NOTE: Includes the canary tiers
     * @returns
     */
    getNumberOfTiers(): Promise<number>;
    /**
     * Returns the prize pool's last awarded draw ID
     * @returns
     */
    getLastAwardedDrawId(): Promise<number>;
    /**
     * Returns the total token amount contributed by all vaults for the given draw IDs
     * @param startDrawId start draw ID (inclusive)
     * @param endDrawId end draw ID (inclusive)
     * @returns
     */
    getTotalContributedAmount(startDrawId: number, endDrawId: number): Promise<bigint>;
    /**
     * Returns the token amounts contributed by any vaults for the given draw IDs
     * @param vaultAddresses vault addresses to get contributions from
     * @param startDrawId start draw ID (inclusive)
     * @param endDrawId end draw ID (inclusive)
     * @returns
     */
    getVaultContributedAmounts(vaultAddresses: Address[], startDrawId: number, endDrawId: number): Promise<{
        [vaultId: string]: bigint;
    }>;
    /**
     * Returns the percentage of the total prize pool contributions for any vaults for the given draw IDs
     *
     * NOTE: Percentage value from 0 to 1 (eg: 0.25 representing 25%)
     * @param vaultAddresses vault addresses to get contributions from
     * @param startDrawId start draw ID (inclusive)
     * @param endDrawId end draw ID (inclusive)
     * @returns
     */
    getVaultContributedPercentages(vaultAddresses: Address[], startDrawId: number, endDrawId: number): Promise<{
        [vaultId: string]: number;
    }>;
    /**
     * Returns the total supply TWAB for any vaults over the last N draws
     * @param vaultAddresses vault addresses to get total supply TWAB for
     * @param numDraws the number of draws to look back on
     * @returns
     */
    getVaultTotalSupplyTwabs(vaultAddresses: Address[], numDraws: number): Promise<{
        [vaultId: string]: bigint;
    }>;
    /**
     * Returns the opened at timestamp of the first ever draw (in seconds)
     * @returns
     */
    getFirstDrawOpenedAt(): Promise<number>;
    /**
     * Returns the opened at timestamp of the last awarded draw (in seconds)
     * @returns
     */
    getLastAwardedDrawOpenedAt(): Promise<number>;
    /**
     * Checks if a user has won a specific prize tier and index while deposited in a given vault
     * @param vaultAddress vault address to check
     * @param userAddress user address to check prizes for
     * @param tier prize tier to check
     * @param prizeIndex prize index to check
     * @returns
     */
    isWinner(vaultAddress: Address, userAddress: Address, tier: number, prizeIndex: number): Promise<boolean>;
    /**
     * Returns the prize size of a given tier
     * @param tier prize tier
     * @returns
     */
    getTierPrizeSize(tier: number): Promise<bigint>;
    /**
     * Returns the estimated time to award a given tier (in seconds)
     * @param tier prize tier
     * @returns
     */
    getEstimatedTierAwardTime(tier: number): Promise<number>;
    /**
     * Returns the estimated number of prizes awarded based on number of tiers active
     * @param options optional settings
     * @returns
     */
    getEstimatedPrizeCount(options?: {
        includeCanary?: boolean;
    }): Promise<number>;
    /**
     * Returns current and estimated prize amounts and frequency for all prize tiers
     * @param options optional settings
     * @returns
     */
    getAllPrizeInfo(options?: {
        considerPastDraws?: number;
    }): Promise<PrizeInfo[]>;
    /**
     * Returns the utilization rate for all tiers' liquidity
     * @returns
     */
    getTierLiquidityUtilizationRate(): Promise<bigint>;
    /**
     * Returns the total amount of prizes available on the prize pool
     * @returns
     */
    getTotalPrizesAvailable(): Promise<bigint>;
    /**
     * Returns the number of draws targeted to distribute the grand prize
     * @returns
     */
    getGrandPrizePeriodDraws(): Promise<number>;
    /**
     * Submits a transaction to claim a prize from the prize pool
     * @param winner the wallet address that won a given tier's prize
     * @param tier the prize tier to claim
     * @param prizeIndex the prize index to claim
     * @param options optional settings and overrides for this transaction
     * @returns
     */
    claimPrize(winner: Address, tier: number, prizeIndex: number, options?: {
        recipient?: Address;
        fee?: {
            amount: bigint;
            recipient: Address;
        };
        overrides?: TxOverrides;
    }): Promise<`0x${string}`>;
    /**
     * Submits a transaction to close the currently open draw
     * @param winningRandomNumber randomly generated winning number
     * @param overrides optional overrides for this transaction
     * @returns
     */
    closeDraw(winningRandomNumber: bigint, overrides?: TxOverrides): Promise<`0x${string}`>;
    /**
     * Returns the number of prizes in a given prize tier
     * @param tier prize tier
     * @returns
     */
    getTierPrizeCount(tier: number): number;
}

/**
 * This class provides read and write functions to interact with a vault
 */
declare class Vault {
    chainId: number;
    address: Address;
    publicClient: PublicClient;
    readonly id: string;
    walletClient: WalletClient | undefined;
    decimals: number | undefined;
    tokenAddress: Address | undefined;
    tokenData: TokenWithSupply | undefined;
    shareData: TokenWithSupply | undefined;
    exchangeRate: bigint | undefined;
    liquidationPair: Address | undefined;
    claimer: Address | undefined;
    yieldSource: Address | undefined;
    twabController: Address | undefined;
    feePercent: number | undefined;
    feeRecipient: Address | undefined;
    feesAvailable: bigint | undefined;
    owner: Address | undefined;
    name: string | undefined;
    logoURI: string | undefined;
    tags: string[] | undefined;
    tokenLogoURI: string | undefined;
    yieldSourceName: string | undefined;
    yieldSourceURI: string | undefined;
    /**
     * Creates an instance of a Vault with a given public and optional wallet client
     *
     * NOTE: If initialized without a wallet Viem client, write functions will not be available
     * @param chainId the vault's chain ID
     * @param address the vault's address
     * @param publicClient a public Viem client for the network the vault is deployed on
     * @param options optional parameters (including wallet client)
     */
    constructor(chainId: number, address: Address, publicClient: PublicClient, options?: {
        walletClient?: WalletClient;
        decimals?: number;
        tokenAddress?: Address;
        name?: string;
        logoURI?: string;
        tags?: string[];
        tokenLogoURI?: string;
        yieldSourceName?: string;
        yieldSourceURI?: string;
    });
    /**
     * Returns the address of the vault's underlying asset
     * @returns
     */
    getTokenAddress(): Promise<Address>;
    /**
     * Returns basic data about the vault's underlying asset
     * @returns
     */
    getTokenData(): Promise<TokenWithSupply>;
    /**
     * Returns basic data about the vault's share token
     * @returns
     */
    getShareData(): Promise<TokenWithSupply>;
    /**
     * Returns a user's balance for the vault's underlying asset
     * @param userAddress the user's address to get a balance for
     * @returns
     */
    getUserTokenBalance(userAddress: string): Promise<TokenWithAmount>;
    /**
     * Returns a user's balance for the vault's share token
     * @param userAddress the user's address to get a balance for
     * @returns
     */
    getUserShareBalance(userAddress: string): Promise<TokenWithAmount>;
    /**
     * Returns a user's delegate balance for the vault's share token
     * @param userAddress the user's address to get a balance for
     * @returns
     */
    getUserDelegateBalance(userAddress: string): Promise<bigint>;
    /**
     * Returns a user's delegate for the vault
     * @param userAddress the user's address to get delegate for
     * @returns
     */
    getUserDelegate(userAddress: string): Promise<Address>;
    /**
     * Returns a user's allowance for the vault's underlying asset
     * @param userAddress the user's address to get an allowance for
     * @returns
     */
    getUserTokenAllowance(userAddress: string): Promise<bigint>;
    /**
     * Returns the equivalent amount of underlying assets from a share amount
     * @param shares the amount of shares to convert
     * @returns
     */
    getAssetsFromShares(shares: bigint): Promise<bigint>;
    /**
     * Returns the equivalent amount of shares from an underlying asset amount
     * @param assets the amount of assets to convert
     * @returns
     */
    getSharesFromAssets(assets: bigint): Promise<bigint>;
    /**
     * Returns the total amount of underlying assets deposited in the vault
     * @returns
     */
    getTotalTokenBalance(): Promise<TokenWithAmount>;
    /**
     * Returns the exchange rate from 1 share to the vault's underlying asset
     * @returns
     */
    getExchangeRate(): Promise<bigint>;
    /**
     * Returns the address of the vault's currently set liquidation pair contract
     * @returns
     */
    getLiquidationPair(): Promise<Address>;
    /**
     * Returns the address of the vault's currently set claimer contract
     * @returns
     */
    getClaimer(): Promise<Address>;
    /**
     * Returns the address of the vault's underlying yield source
     * @returns
     */
    getYieldSource(): Promise<Address>;
    /**
     * Returns the address of the vault's TWAB controller
     * @returns
     */
    getTWABController(): Promise<Address>;
    /**
     * Returns the vault's current fee configuration
     * @returns
     */
    getFeeInfo(): Promise<{
        percent: number;
        recipient: Address;
    }>;
    /**
     * Returns the vault's currently available fee balance to claim
     * @returns
     */
    getFeesAvailable(): Promise<bigint>;
    /**
     * Returns the address of the vault's owner
     * @returns
     */
    getOwner(): Promise<Address>;
    /**
     * Returns the vault's total delegate supply (total supply - sponsored supply)
     * @returns
     */
    getTotalDelegateSupply(): Promise<bigint>;
    /**
     * Submits a transaction to deposit into the vault
     * @param amount an unformatted token amount (w/ decimals)
     * @param overrides optional overrides for this transaction
     * @returns
     */
    deposit(amount: bigint, overrides?: TxOverrides): Promise<`0x${string}`>;
    /**
     * Submits a transaction to deposit into the vault and send shares to another address
     * @param amount an unformatted token amount (w/ decimals)
     * @param receiver the address to send shares to
     * @param overrides optional overrides for this transaction
     * @returns
     */
    depositTo(amount: bigint, receiver: Address, overrides?: TxOverrides): Promise<`0x${string}`>;
    /**
     * Submits a transaction to withdraw from the vault
     * @param amount an unformatted token amount (w/ decimals)
     * @param options optional args or tx overrides
     * @returns
     */
    withdraw(amount: bigint, options?: {
        maxShares?: bigint;
        overrides?: TxOverrides;
    }): Promise<`0x${string}`>;
    /**
     * Submits a transaction to withdraw from the vault and send underlying assets to another address
     * @param amount an unformatted token amount (w/ decimals)
     * @param receiver the address to send assets to
     * @param options optional args or tx overrides
     * @returns
     */
    withdrawTo(amount: bigint, receiver: Address, options?: {
        maxShares?: bigint;
        overrides?: TxOverrides;
    }): Promise<`0x${string}`>;
    /**
     * Submits a transaction to redeem shares from the vault
     * @param amount an unformatted share amount (w/ decimals)
     * @param options optional args or tx overrides
     * @returns
     */
    redeem(amount: bigint, options?: {
        minAssets?: bigint;
        overrides?: TxOverrides;
    }): Promise<`0x${string}`>;
    /**
     * Submits a transaction to redeem shares from the vault and send underlying assets to another address
     * @param amount an unformatted share amount (w/ decimals)
     * @param receiver the address to send assets to
     * @param options optional args or tx overrides
     * @returns
     */
    redeemTo(amount: bigint, receiver: Address, options?: {
        minAssets?: bigint;
        overrides?: TxOverrides;
    }): Promise<`0x${string}`>;
    /**
     * Submits a transaction to set an allowance for vault deposits
     * @param amount an unformatted token amount (w/ decimals)
     * @param overrides optional overrides for this transaction
     * @returns
     */
    approveDeposit(amount: bigint, overrides?: TxOverrides): Promise<`0x${string}`>;
    /**
     * Submits a transaction to set an allowance of 0 for vault deposits
     * @param overrides optional overrides for this transaction
     * @returns
     */
    revokeAllowance(overrides?: TxOverrides): Promise<`0x${string}`>;
    /**
     * Submits a transaction to claim yield fees
     * @param amount an unformatted share amount (w/ decimals)
     * @param overrides optional overrides for this transaction
     * @returns
     */
    claimFees(amount: bigint, overrides?: TxOverrides): Promise<`0x${string}`>;
}

/**
 * This class provides read-only functions to fetch onchain data from any vaults in vault list(s)
 */
declare class Vaults {
    allVaultInfo: VaultInfo[];
    publicClients: {
        [chainId: number]: PublicClient;
    };
    readonly vaults: {
        [vaultId: string]: Vault;
    };
    readonly chainIds: number[];
    readonly vaultAddresses: {
        [chainId: number]: Address[];
    };
    underlyingTokenData: {
        [vaultId: string]: TokenWithSupply;
    } | undefined;
    underlyingTokenAddresses: {
        byChain: {
            [chainId: number]: Address[];
        };
        byVault: {
            [vaultId: string]: Address;
        };
    } | undefined;
    /**
     * Creates an instance of a Vaults object with clients to query onchain data with
     * @param vaults a list of vaults
     * @param publicClients Public Viem clients for each network to create Vault objects for
     */
    constructor(allVaultInfo: VaultInfo[], publicClients: {
        [chainId: number]: PublicClient;
    });
    /**
     * Returns basic data about each vault's underlying asset
     * @returns
     */
    getTokenData(): Promise<{
        [vaultId: string]: TokenWithSupply;
    }>;
    /**
     * Returns basic data about each vault's share token
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getShareData(chainIds?: number[]): Promise<{
        [vaultId: string]: TokenWithSupply;
    }>;
    /**
     * Returns a user's balances for each vaults' underlying assets
     * @param userAddress the user's address to get balances for
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getUserTokenBalances(userAddress: string, chainIds?: number[]): Promise<{
        [vaultId: string]: TokenWithAmount;
    }>;
    /**
     * Returns a user's balances for each vaults' share tokens
     * @param userAddress the user's address to get balances for
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getUserShareBalances(userAddress: string, chainIds?: number[]): Promise<{
        [vaultId: string]: TokenWithAmount;
    }>;
    /**
     * Returns the total amount of underlying assets deposited in each vault
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getTotalTokenBalances(chainIds?: number[]): Promise<{
        [vaultId: string]: TokenWithAmount;
    }>;
    /**
     * Returns a user's delegate balances for each vaults' share tokens
     * @param userAddress the user's address to get balances for
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getUserDelegateBalances(userAddress: string, chainIds?: number[]): Promise<{
        [vaultId: string]: bigint;
    }>;
    /**
     * Returns a user's delegates for each vault
     * @param userAddress the user's address to get delegates for
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getUserDelegates(userAddress: string, chainIds?: number[]): Promise<{
        [vaultId: string]: Address;
    }>;
    /**
     * Returns the exchange rate from 1 share to each vaults' underlying assets
     * @param chainIds optional chain IDs to query (by default queries all)
     * @returns
     */
    getExchangeRates(chainIds?: number[]): Promise<{
        [vaultId: string]: bigint;
    }>;
    /**
     * Returns the unique underlying token addresses for all vaults
     * @returns
     */
    getUnderlyingTokenAddresses(): Promise<{
        byChain: {
            [chainId: number]: Address[];
        };
        byVault: {
            [vaultId: string]: Address;
        };
    }>;
    /**
     * Returns each vault's total delegate supply (total supply - sponsored supply)
     * @returns
     */
    getTotalDelegateSupplies(): Promise<{
        [vaultId: string]: bigint;
    }>;
}

declare const claimerABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract PrizePool";
        readonly name: "_prizePool";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_timeToReachMaxFee";
        readonly type: "uint256";
    }, {
        readonly internalType: "UD2x18";
        readonly name: "_maxFeePortionOfPrize";
        readonly type: "uint64";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "winnersLength";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "prizeIndicesLength";
        readonly type: "uint256";
    }];
    readonly name: "ClaimArraySizeMismatch";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "FeeRecipientZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv18_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "denominator";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "int256";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Convert_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "int256";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Convert_Underflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PRBMath_SD59x18_Div_InputTooSmall";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }, {
        readonly internalType: "SD59x18";
        readonly name: "y";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Div_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_UD60x18_Convert_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizePoolZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TimeToReachMaxFeeZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "minFee";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "fee";
        readonly type: "uint256";
    }];
    readonly name: "VrgdaClaimFeeBelowMin";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "contract IClaimable";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "winner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint32";
        readonly name: "prizeIndex";
        readonly type: "uint32";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes";
        readonly name: "reason";
        readonly type: "bytes";
    }];
    readonly name: "ClaimError";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract IClaimable";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "address[]";
        readonly name: "_winners";
        readonly type: "address[]";
    }, {
        readonly internalType: "uint32[][]";
        readonly name: "_prizeIndices";
        readonly type: "uint32[][]";
    }, {
        readonly internalType: "address";
        readonly name: "_feeRecipient";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_minFeePerClaim";
        readonly type: "uint256";
    }];
    readonly name: "claimPrizes";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "totalFees";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint256";
        readonly name: "_claimCount";
        readonly type: "uint256";
    }];
    readonly name: "computeFeePerClaim";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "computeMaxFee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint256";
        readonly name: "_claimCount";
        readonly type: "uint256";
    }];
    readonly name: "computeTotalFees";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint256";
        readonly name: "_claimCount";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_claimedCount";
        readonly type: "uint256";
    }];
    readonly name: "computeTotalFees";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "maxFeePortionOfPrize";
    readonly outputs: readonly [{
        readonly internalType: "UD2x18";
        readonly name: "";
        readonly type: "uint64";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizePool";
    readonly outputs: readonly [{
        readonly internalType: "contract PrizePool";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "timeToReachMaxFee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const curveLpTokenABI: readonly [{
    readonly name: "Transfer";
    readonly inputs: readonly [{
        readonly name: "sender";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "receiver";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "Approval";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "spender";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "value";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "TokenExchange";
    readonly inputs: readonly [{
        readonly name: "buyer";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "sold_id";
        readonly type: "int128";
        readonly indexed: false;
    }, {
        readonly name: "tokens_sold";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "bought_id";
        readonly type: "int128";
        readonly indexed: false;
    }, {
        readonly name: "tokens_bought";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "AddLiquidity";
    readonly inputs: readonly [{
        readonly name: "provider";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "token_amounts";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "fees";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "invariant";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "token_supply";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "RemoveLiquidity";
    readonly inputs: readonly [{
        readonly name: "provider";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "token_amounts";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "fees";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "token_supply";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "RemoveLiquidityOne";
    readonly inputs: readonly [{
        readonly name: "provider";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "token_amount";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "coin_amount";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "token_supply";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "RemoveLiquidityImbalance";
    readonly inputs: readonly [{
        readonly name: "provider";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "token_amounts";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "fees";
        readonly type: "uint256[2]";
        readonly indexed: false;
    }, {
        readonly name: "invariant";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "token_supply";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "RampA";
    readonly inputs: readonly [{
        readonly name: "old_A";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "new_A";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "initial_time";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "future_time";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "StopRampA";
    readonly inputs: readonly [{
        readonly name: "A";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "t";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "CommitNewFee";
    readonly inputs: readonly [{
        readonly name: "new_fee";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly name: "ApplyNewFee";
    readonly inputs: readonly [{
        readonly name: "fee";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly anonymous: false;
    readonly type: "event";
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "initialize";
    readonly inputs: readonly [{
        readonly name: "_name";
        readonly type: "string";
    }, {
        readonly name: "_symbol";
        readonly type: "string";
    }, {
        readonly name: "_coins";
        readonly type: "address[4]";
    }, {
        readonly name: "_rate_multipliers";
        readonly type: "uint256[4]";
    }, {
        readonly name: "_A";
        readonly type: "uint256";
    }, {
        readonly name: "_fee";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "decimals";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint8";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "transfer";
    readonly inputs: readonly [{
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly name: "_value";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "transferFrom";
    readonly inputs: readonly [{
        readonly name: "_from";
        readonly type: "address";
    }, {
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly name: "_value";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "approve";
    readonly inputs: readonly [{
        readonly name: "_spender";
        readonly type: "address";
    }, {
        readonly name: "_value";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "permit";
    readonly inputs: readonly [{
        readonly name: "_owner";
        readonly type: "address";
    }, {
        readonly name: "_spender";
        readonly type: "address";
    }, {
        readonly name: "_value";
        readonly type: "uint256";
    }, {
        readonly name: "_deadline";
        readonly type: "uint256";
    }, {
        readonly name: "_v";
        readonly type: "uint8";
    }, {
        readonly name: "_r";
        readonly type: "bytes32";
    }, {
        readonly name: "_s";
        readonly type: "bytes32";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "last_price";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "ema_price";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "get_balances";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256[2]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "admin_fee";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "A";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "A_precise";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "get_p";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "price_oracle";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "get_virtual_price";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "calc_token_amount";
    readonly inputs: readonly [{
        readonly name: "_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_is_deposit";
        readonly type: "bool";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "add_liquidity";
    readonly inputs: readonly [{
        readonly name: "_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_min_mint_amount";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "add_liquidity";
    readonly inputs: readonly [{
        readonly name: "_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_min_mint_amount";
        readonly type: "uint256";
    }, {
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "get_dy";
    readonly inputs: readonly [{
        readonly name: "i";
        readonly type: "int128";
    }, {
        readonly name: "j";
        readonly type: "int128";
    }, {
        readonly name: "dx";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "exchange";
    readonly inputs: readonly [{
        readonly name: "i";
        readonly type: "int128";
    }, {
        readonly name: "j";
        readonly type: "int128";
    }, {
        readonly name: "_dx";
        readonly type: "uint256";
    }, {
        readonly name: "_min_dy";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "exchange";
    readonly inputs: readonly [{
        readonly name: "i";
        readonly type: "int128";
    }, {
        readonly name: "j";
        readonly type: "int128";
    }, {
        readonly name: "_dx";
        readonly type: "uint256";
    }, {
        readonly name: "_min_dy";
        readonly type: "uint256";
    }, {
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity";
    readonly inputs: readonly [{
        readonly name: "_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "_min_amounts";
        readonly type: "uint256[2]";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256[2]";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity";
    readonly inputs: readonly [{
        readonly name: "_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "_min_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256[2]";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity_imbalance";
    readonly inputs: readonly [{
        readonly name: "_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_max_burn_amount";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity_imbalance";
    readonly inputs: readonly [{
        readonly name: "_amounts";
        readonly type: "uint256[2]";
    }, {
        readonly name: "_max_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "calc_withdraw_one_coin";
    readonly inputs: readonly [{
        readonly name: "_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "i";
        readonly type: "int128";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity_one_coin";
    readonly inputs: readonly [{
        readonly name: "_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "i";
        readonly type: "int128";
    }, {
        readonly name: "_min_received";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "remove_liquidity_one_coin";
    readonly inputs: readonly [{
        readonly name: "_burn_amount";
        readonly type: "uint256";
    }, {
        readonly name: "i";
        readonly type: "int128";
    }, {
        readonly name: "_min_received";
        readonly type: "uint256";
    }, {
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "ramp_A";
    readonly inputs: readonly [{
        readonly name: "_future_A";
        readonly type: "uint256";
    }, {
        readonly name: "_future_time";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "stop_ramp_A";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "set_ma_exp_time";
    readonly inputs: readonly [{
        readonly name: "_ma_exp_time";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "admin_balances";
    readonly inputs: readonly [{
        readonly name: "i";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "commit_new_fee";
    readonly inputs: readonly [{
        readonly name: "_new_fee";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "apply_new_fee";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly name: "withdraw_admin_fees";
    readonly inputs: readonly [];
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "pure";
    readonly type: "function";
    readonly name: "version";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "coins";
    readonly inputs: readonly [{
        readonly name: "arg0";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "balances";
    readonly inputs: readonly [{
        readonly name: "arg0";
        readonly type: "uint256";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "fee";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "future_fee";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "admin_action_deadline";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "initial_A";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "future_A";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "initial_A_time";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "future_A_time";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "name";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "symbol";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "balanceOf";
    readonly inputs: readonly [{
        readonly name: "arg0";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "allowance";
    readonly inputs: readonly [{
        readonly name: "arg0";
        readonly type: "address";
    }, {
        readonly name: "arg1";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "totalSupply";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "DOMAIN_SEPARATOR";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "bytes32";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "nonces";
    readonly inputs: readonly [{
        readonly name: "arg0";
        readonly type: "address";
    }];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "ma_exp_time";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly name: "ma_last_time";
    readonly inputs: readonly [];
    readonly outputs: readonly [{
        readonly name: "";
        readonly type: "uint256";
    }];
}];

declare const drawManagerABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract PrizePool";
        readonly name: "_prizePool";
        readonly type: "address";
    }, {
        readonly internalType: "contract IRng";
        readonly name: "_rng";
        readonly type: "address";
    }, {
        readonly internalType: "uint48";
        readonly name: "_auctionDuration";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint48";
        readonly name: "_auctionTargetTime";
        readonly type: "uint48";
    }, {
        readonly internalType: "UD2x18";
        readonly name: "_firstStartDrawTargetFraction";
        readonly type: "uint64";
    }, {
        readonly internalType: "UD2x18";
        readonly name: "_firstFinishDrawTargetFraction";
        readonly type: "uint64";
    }, {
        readonly internalType: "uint256";
        readonly name: "_maxRewards";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_maxRetries";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_vaultBeneficiary";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "AlreadyStartedDraw";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "auctionDuration";
        readonly type: "uint48";
    }];
    readonly name: "AuctionDurationGTDrawPeriodSeconds";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "AuctionExpired";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "auctionTargetTime";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint48";
        readonly name: "auctionDuration";
        readonly type: "uint48";
    }];
    readonly name: "AuctionTargetTimeExceedsDuration";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DrawHasFinalized";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DrawHasNotClosed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv18_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "denominator";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_UD60x18_Convert_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "UD60x18";
        readonly name: "x";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_UD60x18_IntoUD2x18_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RetryLimitReached";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RewardRecipientIsZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RngRequestNotComplete";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RngRequestNotInSameBlock";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "StaleRngRequest";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TargetRewardFractionGTOne";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "contribution";
        readonly type: "uint256";
    }];
    readonly name: "DrawFinished";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint32";
        readonly name: "rngRequestId";
        readonly type: "uint32";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "count";
        readonly type: "uint64";
    }];
    readonly name: "DrawStarted";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "auctionDuration";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "auctionTargetTime";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "canFinishDraw";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "canStartDraw";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_rewardRecipient";
        readonly type: "address";
    }];
    readonly name: "finishDraw";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "finishDrawReward";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getLastStartDrawAuction";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }, {
            readonly internalType: "uint40";
            readonly name: "closedAt";
            readonly type: "uint40";
        }, {
            readonly internalType: "uint24";
            readonly name: "drawId";
            readonly type: "uint24";
        }, {
            readonly internalType: "uint32";
            readonly name: "rngRequestId";
            readonly type: "uint32";
        }];
        readonly internalType: "struct StartDrawAuction";
        readonly name: "result";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_index";
        readonly type: "uint256";
    }];
    readonly name: "getStartDrawAuction";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }, {
            readonly internalType: "uint40";
            readonly name: "closedAt";
            readonly type: "uint40";
        }, {
            readonly internalType: "uint24";
            readonly name: "drawId";
            readonly type: "uint24";
        }, {
            readonly internalType: "uint32";
            readonly name: "rngRequestId";
            readonly type: "uint32";
        }];
        readonly internalType: "struct StartDrawAuction";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getStartDrawAuctionCount";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastFinishDrawFraction";
    readonly outputs: readonly [{
        readonly internalType: "UD2x18";
        readonly name: "";
        readonly type: "uint64";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastStartDrawFraction";
    readonly outputs: readonly [{
        readonly internalType: "UD2x18";
        readonly name: "";
        readonly type: "uint64";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "maxRetries";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "maxRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizePool";
    readonly outputs: readonly [{
        readonly internalType: "contract PrizePool";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "rng";
    readonly outputs: readonly [{
        readonly internalType: "contract IRng";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_rewardRecipient";
        readonly type: "address";
    }, {
        readonly internalType: "uint32";
        readonly name: "_rngRequestId";
        readonly type: "uint32";
    }];
    readonly name: "startDraw";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "startDrawReward";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "vaultBeneficiary";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const erc20OldPermitABI: readonly [{
    readonly inputs: readonly [];
    readonly name: "DOMAIN_SEPARATOR";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "PERMIT_TYPEHASH";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "allowance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "decimals";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "mint";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "name";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "nonces";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "holder";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "nonce";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "expiry";
        readonly type: "uint256";
    }, {
        readonly internalType: "bool";
        readonly name: "allowed";
        readonly type: "bool";
    }, {
        readonly internalType: "uint8";
        readonly name: "v";
        readonly type: "uint8";
    }, {
        readonly internalType: "bytes32";
        readonly name: "r";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes32";
        readonly name: "s";
        readonly type: "bytes32";
    }];
    readonly name: "permit";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "symbol";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "transfer";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "version";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Approval";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}];

declare const erc20ABI: readonly [{
    readonly inputs: readonly [];
    readonly name: "DOMAIN_SEPARATOR";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "PERMIT_TYPEHASH";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "allowance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "decimals";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "eip712Domain";
    readonly outputs: readonly [{
        readonly internalType: "bytes1";
        readonly name: "fields";
        readonly type: "bytes1";
    }, {
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "version";
        readonly type: "string";
    }, {
        readonly internalType: "uint256";
        readonly name: "chainId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "verifyingContract";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "salt";
        readonly type: "bytes32";
    }, {
        readonly internalType: "uint256[]";
        readonly name: "extensions";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "mint";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "name";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "nonces";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "deadline";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "v";
        readonly type: "uint8";
    }, {
        readonly internalType: "bytes32";
        readonly name: "r";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes32";
        readonly name: "s";
        readonly type: "bytes32";
    }];
    readonly name: "permit";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "symbol";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "transfer";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "version";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Approval";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}];

declare const liquidationPairABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract ILiquidationSource";
        readonly name: "_source";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "__tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "__tokenOut";
        readonly type: "address";
    }, {
        readonly internalType: "uint64";
        readonly name: "_targetAuctionPeriod";
        readonly type: "uint64";
    }, {
        readonly internalType: "uint192";
        readonly name: "_targetAuctionPrice";
        readonly type: "uint192";
    }, {
        readonly internalType: "uint256";
        readonly name: "_smoothingFactor";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "requested";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "available";
        readonly type: "uint256";
    }];
    readonly name: "InsufficientBalance";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ReceiverIsZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "SmoothingGteOne";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountInMax";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }];
    readonly name: "SwapExceedsMax";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "receiver";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountInMax";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes";
        readonly name: "flashSwapData";
        readonly type: "bytes";
    }];
    readonly name: "SwappedExactAmountOut";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "computeExactAmountIn";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "price";
        readonly type: "uint256";
    }];
    readonly name: "computeTimeForPrice";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastAuctionAt";
    readonly outputs: readonly [{
        readonly internalType: "uint64";
        readonly name: "";
        readonly type: "uint64";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastAuctionPrice";
    readonly outputs: readonly [{
        readonly internalType: "uint192";
        readonly name: "";
        readonly type: "uint192";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "maxAmountOut";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "smoothingFactor";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "source";
    readonly outputs: readonly [{
        readonly internalType: "contract ILiquidationSource";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountInMax";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "_flashSwapData";
        readonly type: "bytes";
    }];
    readonly name: "swapExactAmountOut";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "target";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "targetAuctionPeriod";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tokenIn";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tokenOut";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const liquidationPairFactoryABI: readonly [{
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "contract TpdaLiquidationPair";
        readonly name: "pair";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "contract ILiquidationSource";
        readonly name: "source";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "tokenOut";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "targetAuctionPeriod";
        readonly type: "uint64";
    }, {
        readonly indexed: false;
        readonly internalType: "uint192";
        readonly name: "targetAuctionPrice";
        readonly type: "uint192";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "smoothingFactor";
        readonly type: "uint256";
    }];
    readonly name: "PairCreated";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "allPairs";
    readonly outputs: readonly [{
        readonly internalType: "contract TpdaLiquidationPair";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract ILiquidationSource";
        readonly name: "_source";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_tokenOut";
        readonly type: "address";
    }, {
        readonly internalType: "uint64";
        readonly name: "_targetAuctionPeriod";
        readonly type: "uint64";
    }, {
        readonly internalType: "uint192";
        readonly name: "_targetAuctionPrice";
        readonly type: "uint192";
    }, {
        readonly internalType: "uint256";
        readonly name: "_smoothingFactor";
        readonly type: "uint256";
    }];
    readonly name: "createPair";
    readonly outputs: readonly [{
        readonly internalType: "contract TpdaLiquidationPair";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "pair";
        readonly type: "address";
    }];
    readonly name: "deployedPairs";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "wasDeployed";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalPairs";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const liquidationRouterABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract TpdaLiquidationPairFactory";
        readonly name: "liquidationPairFactory_";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }];
    readonly name: "InvalidSender";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "deadline";
        readonly type: "uint256";
    }];
    readonly name: "SwapExpired";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "UndefinedTpdaLiquidationPairFactory";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "liquidationPair";
        readonly type: "address";
    }];
    readonly name: "UnknownTpdaLiquidationPair";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "contract TpdaLiquidationPairFactory";
        readonly name: "liquidationPairFactory";
        readonly type: "address";
    }];
    readonly name: "LiquidationRouterCreated";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "contract TpdaLiquidationPair";
        readonly name: "liquidationPair";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "receiver";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountInMax";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "deadline";
        readonly type: "uint256";
    }];
    readonly name: "SwappedExactAmountOut";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_sender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "_flashSwapData";
        readonly type: "bytes";
    }];
    readonly name: "flashSwapCallback";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract TpdaLiquidationPair";
        readonly name: "_liquidationPair";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountInMax";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_deadline";
        readonly type: "uint256";
    }];
    readonly name: "swapExactAmountOut";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const lpTokenABI: readonly [{
    readonly inputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "BelowMinimumK";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DepositsNotEqual";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "FactoryAlreadySet";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InsufficientInputAmount";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InsufficientLiquidity";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InsufficientLiquidityBurned";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InsufficientLiquidityMinted";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InsufficientOutputAmount";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InvalidTo";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "IsPaused";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "K";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "NotEmergencyCouncil";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "str";
        readonly type: "string";
    }];
    readonly name: "StringTooLong";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Approval";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1";
        readonly type: "uint256";
    }];
    readonly name: "Burn";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1";
        readonly type: "uint256";
    }];
    readonly name: "Claim";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [];
    readonly name: "EIP712DomainChanged";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1";
        readonly type: "uint256";
    }];
    readonly name: "Fees";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1";
        readonly type: "uint256";
    }];
    readonly name: "Mint";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0In";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1In";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount0Out";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount1Out";
        readonly type: "uint256";
    }];
    readonly name: "Swap";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reserve0";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reserve1";
        readonly type: "uint256";
    }];
    readonly name: "Sync";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "DOMAIN_SEPARATOR";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }];
    readonly name: "allowance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "blockTimestampLast";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }];
    readonly name: "burn";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amount0";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount1";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "claimFees";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "claimed0";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "claimed1";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "claimable0";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "claimable1";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "currentCumulativePrices";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "reserve0Cumulative";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "reserve1Cumulative";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "blockTimestamp";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "decimals";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "subtractedValue";
        readonly type: "uint256";
    }];
    readonly name: "decreaseAllowance";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "eip712Domain";
    readonly outputs: readonly [{
        readonly internalType: "bytes1";
        readonly name: "fields";
        readonly type: "bytes1";
    }, {
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "version";
        readonly type: "string";
    }, {
        readonly internalType: "uint256";
        readonly name: "chainId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "verifyingContract";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "salt";
        readonly type: "bytes32";
    }, {
        readonly internalType: "uint256[]";
        readonly name: "extensions";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "factory";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }];
    readonly name: "getAmountOut";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getReserves";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_reserve0";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_reserve1";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_blockTimestampLast";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "addedValue";
        readonly type: "uint256";
    }];
    readonly name: "increaseAllowance";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "index0";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "index1";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_token0";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_token1";
        readonly type: "address";
    }, {
        readonly internalType: "bool";
        readonly name: "_stable";
        readonly type: "bool";
    }];
    readonly name: "initialize";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastObservation";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "uint256";
            readonly name: "timestamp";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "reserve0Cumulative";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "reserve1Cumulative";
            readonly type: "uint256";
        }];
        readonly internalType: "struct Pool.Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "metadata";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "dec0";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "dec1";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "r0";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "r1";
        readonly type: "uint256";
    }, {
        readonly internalType: "bool";
        readonly name: "st";
        readonly type: "bool";
    }, {
        readonly internalType: "address";
        readonly name: "t0";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "t1";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }];
    readonly name: "mint";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "liquidity";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "name";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly name: "nonces";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "observationLength";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "observations";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "timestamp";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "reserve0Cumulative";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "reserve1Cumulative";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "deadline";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "v";
        readonly type: "uint8";
    }, {
        readonly internalType: "bytes32";
        readonly name: "r";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes32";
        readonly name: "s";
        readonly type: "bytes32";
    }];
    readonly name: "permit";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "poolFees";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "points";
        readonly type: "uint256";
    }];
    readonly name: "prices";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "granularity";
        readonly type: "uint256";
    }];
    readonly name: "quote";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserve0";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserve0CumulativeLast";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserve1";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserve1CumulativeLast";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "points";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "window";
        readonly type: "uint256";
    }];
    readonly name: "sample";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "__name";
        readonly type: "string";
    }];
    readonly name: "setName";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "__symbol";
        readonly type: "string";
    }];
    readonly name: "setSymbol";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }];
    readonly name: "skim";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "stable";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "supplyIndex0";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "supplyIndex1";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amount0Out";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount1Out";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "bytes";
        readonly name: "data";
        readonly type: "bytes";
    }];
    readonly name: "swap";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "symbol";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "sync";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "token0";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "token1";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tokens";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "transfer";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const opGasOracleABI: readonly [{
    readonly inputs: readonly [];
    readonly name: "DECIMALS";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "baseFee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "baseFeeScalar";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "blobBaseFee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "blobBaseFeeScalar";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "decimals";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "gasPrice";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "_data";
        readonly type: "bytes";
    }];
    readonly name: "getL1Fee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "_data";
        readonly type: "bytes";
    }];
    readonly name: "getL1GasUsed";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "isEcotone";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "l1BaseFee";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "overhead";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "scalar";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "setEcotone";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "version";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const poolWideTwabRewardsABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "_twabController";
        readonly type: "address";
    }, {
        readonly internalType: "contract IPrizePool";
        readonly name: "_prizePool";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "EpochDurationLtDrawPeriod";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "EpochDurationNotMultipleOfDrawPeriod";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint64";
        readonly name: "epochEndTimestamp";
        readonly type: "uint64";
    }];
    readonly name: "EpochNotOver";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "epochExtension";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "currentEpochs";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "maxEpochs";
        readonly type: "uint8";
    }];
    readonly name: "ExceedsMaxEpochs";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "gracePeriodEndTimestamp";
        readonly type: "uint256";
    }];
    readonly name: "GracePeriodActive";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "epochId";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "InvalidEpochId";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "startEpochId";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "currentEpochId";
        readonly type: "uint8";
    }];
    readonly name: "NoEpochsToClaim";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "creator";
        readonly type: "address";
    }];
    readonly name: "OnlyPromotionCreator";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PayeeZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizePoolZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }];
    readonly name: "PromotionInactive";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "epochId";
        readonly type: "uint8";
    }];
    readonly name: "RewardsAlreadyClaimed";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "StartTimeLtFirstDrawOpensAt";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "StartTimeNotAlignedWithDraws";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "received";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "expected";
        readonly type: "uint256";
    }];
    readonly name: "TokensReceivedLessThanExpected";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TwabControllerZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroEpochs";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroTokensPerEpoch";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "startTimestamp";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "tokensPerEpoch";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "epochDuration";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "PromotionDestroyed";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "epochNumber";
        readonly type: "uint8";
    }];
    readonly name: "PromotionEnded";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "numberOfEpochs";
        readonly type: "uint256";
    }];
    readonly name: "PromotionExtended";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes32";
        readonly name: "epochClaimFlags";
        readonly type: "bytes32";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "GRACE_PERIOD";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint64";
        readonly name: "_timestamp";
        readonly type: "uint64";
    }];
    readonly name: "calculateDrawIdAt";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "calculateRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "rewards";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_startEpochId";
        readonly type: "uint8";
    }];
    readonly name: "claimRewardedEpochs";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "claimRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract ITwabRewards";
        readonly name: "_twabRewards";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "claimTwabRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "claimedEpochs";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "claimMask";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract IERC20";
        readonly name: "_token";
        readonly type: "address";
    }, {
        readonly internalType: "uint40";
        readonly name: "_startTimestamp";
        readonly type: "uint40";
    }, {
        readonly internalType: "uint104";
        readonly name: "_tokensPerEpoch";
        readonly type: "uint104";
    }, {
        readonly internalType: "uint40";
        readonly name: "_epochDuration";
        readonly type: "uint40";
    }, {
        readonly internalType: "uint8";
        readonly name: "_numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "createPromotion";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }];
    readonly name: "destroyPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }];
    readonly name: "endPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "_epochClaimFlags";
        readonly type: "bytes32";
    }];
    readonly name: "epochBytesToIdArray";
    readonly outputs: readonly [{
        readonly internalType: "uint8[]";
        readonly name: "";
        readonly type: "uint8[]";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "epochIdArrayToBytes";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "_promotionStartTimestamp";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint48";
        readonly name: "_promotionEpochDuration";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint8";
        readonly name: "_epochId";
        readonly type: "uint8";
    }];
    readonly name: "epochRanges";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "epochStartTimestamp";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint48";
        readonly name: "epochEndTimestamp";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint24";
        readonly name: "epochStartDrawId";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "epochEndDrawId";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_epochId";
        readonly type: "uint8";
    }];
    readonly name: "epochRangesForPromotion";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "epochStartTimestamp";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint48";
        readonly name: "epochEndTimestamp";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint24";
        readonly name: "epochStartDrawId";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "epochEndDrawId";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "extendPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_timestamp";
        readonly type: "uint256";
    }];
    readonly name: "getEpochIdAt";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getEpochIdNow";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getPromotion";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "contract IERC20";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint40";
            readonly name: "epochDuration";
            readonly type: "uint40";
        }, {
            readonly internalType: "uint40";
            readonly name: "createdAt";
            readonly type: "uint40";
        }, {
            readonly internalType: "uint8";
            readonly name: "numberOfEpochs";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint40";
            readonly name: "startTimestamp";
            readonly type: "uint40";
        }, {
            readonly internalType: "uint104";
            readonly name: "tokensPerEpoch";
            readonly type: "uint104";
        }, {
            readonly internalType: "uint112";
            readonly name: "rewardsUnclaimed";
            readonly type: "uint112";
        }];
        readonly internalType: "struct Promotion";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getRemainingRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint128";
        readonly name: "";
        readonly type: "uint128";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_epochId";
        readonly type: "uint8";
    }];
    readonly name: "getVaultRewardAmount";
    readonly outputs: readonly [{
        readonly internalType: "uint128";
        readonly name: "";
        readonly type: "uint128";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "latestPromotionId";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "data";
        readonly type: "bytes[]";
    }];
    readonly name: "multicall";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "results";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizePool";
    readonly outputs: readonly [{
        readonly internalType: "contract IPrizePool";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "promotionCreators";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "twabController";
    readonly outputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const prizePoolABI: readonly [{
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "contract IERC20";
            readonly name: "prizeToken";
            readonly type: "address";
        }, {
            readonly internalType: "contract TwabController";
            readonly name: "twabController";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "creator";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "tierLiquidityUtilizationRate";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint48";
            readonly name: "drawPeriodSeconds";
            readonly type: "uint48";
        }, {
            readonly internalType: "uint48";
            readonly name: "firstDrawOpensAt";
            readonly type: "uint48";
        }, {
            readonly internalType: "uint24";
            readonly name: "grandPrizePeriodDraws";
            readonly type: "uint24";
        }, {
            readonly internalType: "uint8";
            readonly name: "numberOfTiers";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint8";
            readonly name: "tierShares";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint8";
            readonly name: "canaryShares";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint8";
            readonly name: "reserveShares";
            readonly type: "uint8";
        }, {
            readonly internalType: "uint24";
            readonly name: "drawTimeout";
            readonly type: "uint24";
        }];
        readonly internalType: "struct ConstructorParams";
        readonly name: "params";
        readonly type: "tuple";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "AddToDrawZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "prizeIndex";
        readonly type: "uint32";
    }];
    readonly name: "AlreadyClaimed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "drawClosesAt";
        readonly type: "uint48";
    }];
    readonly name: "AwardingDrawNotClosed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "drawManager";
        readonly type: "address";
    }];
    readonly name: "CallerNotDrawManager";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ClaimPeriodExpired";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "available";
        readonly type: "uint256";
    }];
    readonly name: "ContributionGTDeltaBalance";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "CreatorIsZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "prizeIndex";
        readonly type: "uint32";
    }];
    readonly name: "DidNotWin";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "newestDrawId";
        readonly type: "uint24";
    }];
    readonly name: "DrawAwarded";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DrawManagerAlreadySet";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DrawTimeoutGTGrandPrizePeriodDraws";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DrawTimeoutIsZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "FirstDrawOpensInPast";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "grandPrizePeriodDraws";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "maxGrandPrizePeriodDraws";
        readonly type: "uint24";
    }];
    readonly name: "GrandPrizePeriodDrawsTooLarge";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "IncompatibleTwabPeriodLength";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "IncompatibleTwabPeriodOffset";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint104";
        readonly name: "requestedLiquidity";
        readonly type: "uint104";
    }];
    readonly name: "InsufficientLiquidity";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint104";
        readonly name: "amount";
        readonly type: "uint104";
    }, {
        readonly internalType: "uint104";
        readonly name: "reserve";
        readonly type: "uint104";
    }];
    readonly name: "InsufficientReserve";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "requested";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "available";
        readonly type: "uint256";
    }];
    readonly name: "InsufficientRewardsError";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "startDrawId";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "endDrawId";
        readonly type: "uint24";
    }];
    readonly name: "InvalidDrawRange";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "invalidPrizeIndex";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint32";
        readonly name: "prizeCount";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }];
    readonly name: "InvalidPrizeIndex";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "numberOfTiers";
        readonly type: "uint8";
    }];
    readonly name: "InvalidTier";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "NoDrawsAwarded";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }];
    readonly name: "NumberOfTiersGreaterThanMaximum";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }];
    readonly name: "NumberOfTiersLessThanMinimum";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "OnlyCreator";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv18_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "y";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "denominator";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_MulDiv_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Ceil_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "int256";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Convert_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "int256";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Convert_Underflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PRBMath_SD59x18_Div_InputTooSmall";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }, {
        readonly internalType: "SD59x18";
        readonly name: "y";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Div_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Exp2_InputTooBig";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Log_InputTooSmall";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PRBMath_SD59x18_Mul_InputTooSmall";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }, {
        readonly internalType: "SD59x18";
        readonly name: "y";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Mul_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Sqrt_NegativeInput";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "x";
        readonly type: "int256";
    }];
    readonly name: "PRBMath_SD59x18_Sqrt_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "x";
        readonly type: "uint256";
    }];
    readonly name: "PRBMath_UD60x18_Convert_Overflow";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizeIsZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizePoolNotShutdown";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizePoolShutdown";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RandomNumberIsZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RangeSizeZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "RewardRecipientZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "maxReward";
        readonly type: "uint256";
    }];
    readonly name: "RewardTooLarge";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TierLiquidityUtilizationRateCannotBeZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TierLiquidityUtilizationRateGreaterThanOne";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "UpperBoundGtZero";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "AllocateRewardFromReserve";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "winner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "tier";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint32";
        readonly name: "prizeIndex";
        readonly type: "uint32";
    }, {
        readonly indexed: false;
        readonly internalType: "uint152";
        readonly name: "payout";
        readonly type: "uint152";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "claimReward";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "address";
        readonly name: "claimRewardRecipient";
        readonly type: "address";
    }];
    readonly name: "ClaimedPrize";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributePrizeTokens";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributedReserve";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "winningRandomNumber";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "lastNumTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "reserve";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint128";
        readonly name: "prizeTokensPerShare";
        readonly type: "uint128";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "drawOpenedAt";
        readonly type: "uint48";
    }];
    readonly name: "DrawAwarded";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "IncreaseClaimRewards";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ReserveConsumed";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "drawManager";
        readonly type: "address";
    }];
    readonly name: "SetDrawManager";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "available";
        readonly type: "uint256";
    }];
    readonly name: "WithdrawRewards";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "DONATOR";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "accountedBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly internalType: "uint96";
        readonly name: "_amount";
        readonly type: "uint96";
    }];
    readonly name: "allocateRewardFromReserve";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "winningRandomNumber_";
        readonly type: "uint256";
    }];
    readonly name: "awardDraw";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "canaryShares";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "claimCount";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "_prizeIndex";
        readonly type: "uint32";
    }, {
        readonly internalType: "address";
        readonly name: "_prizeRecipient";
        readonly type: "address";
    }, {
        readonly internalType: "uint96";
        readonly name: "_claimReward";
        readonly type: "uint96";
    }, {
        readonly internalType: "address";
        readonly name: "_claimRewardRecipient";
        readonly type: "address";
    }];
    readonly name: "claimPrize";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "_claimCount";
        readonly type: "uint32";
    }];
    readonly name: "computeNextNumberOfTiers";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_rangeSize";
        readonly type: "uint24";
    }];
    readonly name: "computeRangeStartDrawIdInclusive";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_account";
        readonly type: "address";
    }];
    readonly name: "computeShutdownPortion";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "uint256";
            readonly name: "numerator";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "denominator";
            readonly type: "uint256";
        }];
        readonly internalType: "struct ShutdownPortion";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_numberOfTiers";
        readonly type: "uint8";
    }];
    readonly name: "computeTotalShares";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_prizeVault";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amount";
        readonly type: "uint256";
    }];
    readonly name: "contributePrizeTokens";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint96";
        readonly name: "_amount";
        readonly type: "uint96";
    }];
    readonly name: "contributeReserve";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_amount";
        readonly type: "uint256";
    }];
    readonly name: "donatePrizeTokens";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }];
    readonly name: "drawClosesAt";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "drawManager";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }];
    readonly name: "drawOpensAt";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "drawPeriodSeconds";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "drawTimeout";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "drawTimeoutAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "estimateNextNumberOfTiers";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }];
    readonly name: "estimatedPrizeCount";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "estimatedPrizeCount";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }];
    readonly name: "estimatedPrizeCountWithBothCanaries";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "estimatedPrizeCountWithBothCanaries";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "firstDrawOpensAt";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint24";
        readonly name: "_startDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }];
    readonly name: "getContributedBetween";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "_startDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }];
    readonly name: "getDonatedBetween";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_timestamp";
        readonly type: "uint256";
    }];
    readonly name: "getDrawId";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getDrawIdToAward";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getLastAwardedDrawId";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getOpenDrawId";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getShutdownDrawId";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getShutdownInfo";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "balance";
        readonly type: "uint256";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint96";
            readonly name: "available";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint160";
            readonly name: "disbursed";
            readonly type: "uint160";
        }];
        readonly internalType: "struct Observation";
        readonly name: "observation";
        readonly type: "tuple";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "getTierAccrualDurationInDraws";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "_numTiers";
        readonly type: "uint8";
    }];
    readonly name: "getTierOdds";
    readonly outputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "";
        readonly type: "int256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "getTierPrizeCount";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "getTierPrizeSize";
    readonly outputs: readonly [{
        readonly internalType: "uint104";
        readonly name: "";
        readonly type: "uint104";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "getTierRemainingLiquidity";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getTotalAccumulatorNewestObservation";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "uint96";
            readonly name: "available";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint160";
            readonly name: "disbursed";
            readonly type: "uint160";
        }];
        readonly internalType: "struct Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "_startDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }];
    readonly name: "getTotalContributedBetween";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getTotalShares";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }];
    readonly name: "getVaultAccumulatorNewestObservation";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "uint96";
            readonly name: "available";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint160";
            readonly name: "disbursed";
            readonly type: "uint160";
        }];
        readonly internalType: "struct Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint24";
        readonly name: "_startDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }];
    readonly name: "getVaultPortion";
    readonly outputs: readonly [{
        readonly internalType: "SD59x18";
        readonly name: "";
        readonly type: "int256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint24";
        readonly name: "_startDrawIdInclusive";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint24";
        readonly name: "_endDrawIdInclusive";
        readonly type: "uint24";
    }];
    readonly name: "getVaultUserBalanceAndTotalSupplyTwab";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "twab";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "twabTotalSupply";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "getWinningRandomNumber";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "grandPrizePeriodDraws";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }];
    readonly name: "isCanaryTier";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }];
    readonly name: "isDrawFinalized";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "isShutdown";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "_prizeIndex";
        readonly type: "uint32";
    }];
    readonly name: "isWinner";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastAwardedDrawAwardedAt";
    readonly outputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "";
        readonly type: "uint48";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "numberOfTiers";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "pendingReserveContributions";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizeToken";
    readonly outputs: readonly [{
        readonly internalType: "contract IERC20";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizeTokenPerShare";
    readonly outputs: readonly [{
        readonly internalType: "uint128";
        readonly name: "";
        readonly type: "uint128";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserve";
    readonly outputs: readonly [{
        readonly internalType: "uint96";
        readonly name: "";
        readonly type: "uint96";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "reserveShares";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_recipient";
        readonly type: "address";
    }];
    readonly name: "rewardBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_drawManager";
        readonly type: "address";
    }];
    readonly name: "setDrawManager";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "shutdownAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_account";
        readonly type: "address";
    }];
    readonly name: "shutdownBalanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tierLiquidityUtilizationRate";
    readonly outputs: readonly [{
        readonly internalType: "UD60x18";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tierShares";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalWithdrawn";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "twabController";
    readonly outputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "_prizeIndex";
        readonly type: "uint32";
    }];
    readonly name: "wasClaimed";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint24";
        readonly name: "_drawId";
        readonly type: "uint24";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "_prizeIndex";
        readonly type: "uint32";
    }];
    readonly name: "wasClaimed";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amount";
        readonly type: "uint256";
    }];
    readonly name: "withdrawRewards";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_recipient";
        readonly type: "address";
    }];
    readonly name: "withdrawShutdownBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const twabControllerABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "_periodLength";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint32";
        readonly name: "_periodOffset";
        readonly type: "uint32";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint96";
        readonly name: "balance";
        readonly type: "uint96";
    }, {
        readonly internalType: "uint96";
        readonly name: "amount";
        readonly type: "uint96";
    }, {
        readonly internalType: "string";
        readonly name: "message";
        readonly type: "string";
    }];
    readonly name: "BalanceLTAmount";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "CannotTransferToSponsorshipAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint96";
        readonly name: "delegateBalance";
        readonly type: "uint96";
    }, {
        readonly internalType: "uint96";
        readonly name: "delegateAmount";
        readonly type: "uint96";
    }, {
        readonly internalType: "string";
        readonly name: "message";
        readonly type: "string";
    }];
    readonly name: "DelegateBalanceLTAmount";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "PeriodOffsetRelativeTimestamp";
        readonly name: "requestedTimestamp";
        readonly type: "uint32";
    }, {
        readonly internalType: "PeriodOffsetRelativeTimestamp";
        readonly name: "oldestTimestamp";
        readonly type: "uint32";
    }];
    readonly name: "InsufficientHistory";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "start";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "end";
        readonly type: "uint256";
    }];
    readonly name: "InvalidTimeRange";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PeriodLengthTooShort";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "periodOffset";
        readonly type: "uint32";
    }];
    readonly name: "PeriodOffsetInFuture";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "delegate";
        readonly type: "address";
    }];
    readonly name: "SameDelegateAlreadySet";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "timestamp";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "currentOverwritePeriodStartedAt";
        readonly type: "uint256";
    }];
    readonly name: "TimestampNotFinalized";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TransferToZeroAddress";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "amount";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateAmount";
        readonly type: "uint96";
    }];
    readonly name: "DecreasedBalance";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "amount";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateAmount";
        readonly type: "uint96";
    }];
    readonly name: "DecreasedTotalSupply";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "delegator";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "delegate";
        readonly type: "address";
    }];
    readonly name: "Delegated";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "amount";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateAmount";
        readonly type: "uint96";
    }];
    readonly name: "IncreasedBalance";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "amount";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateAmount";
        readonly type: "uint96";
    }];
    readonly name: "IncreasedTotalSupply";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "balance";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateBalance";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "bool";
        readonly name: "isNew";
        readonly type: "bool";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly indexed: false;
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "observation";
        readonly type: "tuple";
    }];
    readonly name: "ObservationRecorded";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "balance";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "uint96";
        readonly name: "delegateBalance";
        readonly type: "uint96";
    }, {
        readonly indexed: false;
        readonly internalType: "bool";
        readonly name: "isNew";
        readonly type: "bool";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly indexed: false;
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "observation";
        readonly type: "tuple";
    }];
    readonly name: "TotalSupplyObservationRecorded";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "PERIOD_LENGTH";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "PERIOD_OFFSET";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_from";
        readonly type: "address";
    }, {
        readonly internalType: "uint96";
        readonly name: "_amount";
        readonly type: "uint96";
    }];
    readonly name: "burn";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "currentOverwritePeriodStartedAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }];
    readonly name: "delegate";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "delegateBalanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "delegateOf";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "getAccount";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint96";
                readonly name: "balance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint96";
                readonly name: "delegateBalance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint16";
                readonly name: "nextObservationIndex";
                readonly type: "uint16";
            }, {
                readonly internalType: "uint16";
                readonly name: "cardinality";
                readonly type: "uint16";
            }];
            readonly internalType: "struct TwabLib.AccountDetails";
            readonly name: "details";
            readonly type: "tuple";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint128";
                readonly name: "cumulativeBalance";
                readonly type: "uint128";
            }, {
                readonly internalType: "uint96";
                readonly name: "balance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint32";
                readonly name: "timestamp";
                readonly type: "uint32";
            }];
            readonly internalType: "struct ObservationLib.Observation[17520]";
            readonly name: "observations";
            readonly type: "tuple[17520]";
        }];
        readonly internalType: "struct TwabLib.Account";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "periodEndOnOrAfterTime";
        readonly type: "uint256";
    }];
    readonly name: "getBalanceAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "getNewestObservation";
    readonly outputs: readonly [{
        readonly internalType: "uint16";
        readonly name: "";
        readonly type: "uint16";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "getNewestTotalSupplyObservation";
    readonly outputs: readonly [{
        readonly internalType: "uint16";
        readonly name: "";
        readonly type: "uint16";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "getOldestObservation";
    readonly outputs: readonly [{
        readonly internalType: "uint16";
        readonly name: "";
        readonly type: "uint16";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "getOldestTotalSupplyObservation";
    readonly outputs: readonly [{
        readonly internalType: "uint16";
        readonly name: "";
        readonly type: "uint16";
    }, {
        readonly components: readonly [{
            readonly internalType: "uint128";
            readonly name: "cumulativeBalance";
            readonly type: "uint128";
        }, {
            readonly internalType: "uint96";
            readonly name: "balance";
            readonly type: "uint96";
        }, {
            readonly internalType: "uint32";
            readonly name: "timestamp";
            readonly type: "uint32";
        }];
        readonly internalType: "struct ObservationLib.Observation";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "time";
        readonly type: "uint256";
    }];
    readonly name: "getTimestampPeriod";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "getTotalSupplyAccount";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "uint96";
                readonly name: "balance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint96";
                readonly name: "delegateBalance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint16";
                readonly name: "nextObservationIndex";
                readonly type: "uint16";
            }, {
                readonly internalType: "uint16";
                readonly name: "cardinality";
                readonly type: "uint16";
            }];
            readonly internalType: "struct TwabLib.AccountDetails";
            readonly name: "details";
            readonly type: "tuple";
        }, {
            readonly components: readonly [{
                readonly internalType: "uint128";
                readonly name: "cumulativeBalance";
                readonly type: "uint128";
            }, {
                readonly internalType: "uint96";
                readonly name: "balance";
                readonly type: "uint96";
            }, {
                readonly internalType: "uint32";
                readonly name: "timestamp";
                readonly type: "uint32";
            }];
            readonly internalType: "struct ObservationLib.Observation[17520]";
            readonly name: "observations";
            readonly type: "tuple[17520]";
        }];
        readonly internalType: "struct TwabLib.Account";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "periodEndOnOrAfterTime";
        readonly type: "uint256";
    }];
    readonly name: "getTotalSupplyAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "startTime";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "endTime";
        readonly type: "uint256";
    }];
    readonly name: "getTotalSupplyTwabBetween";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "startTime";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "endTime";
        readonly type: "uint256";
    }];
    readonly name: "getTwabBetween";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "time";
        readonly type: "uint256";
    }];
    readonly name: "hasFinalized";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "timestamp";
        readonly type: "uint256";
    }];
    readonly name: "isShutdownAt";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "lastObservationAt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly internalType: "uint96";
        readonly name: "_amount";
        readonly type: "uint96";
    }];
    readonly name: "mint";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_timestamp";
        readonly type: "uint256";
    }];
    readonly name: "periodEndOnOrAfter";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_from";
        readonly type: "address";
    }];
    readonly name: "sponsor";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "totalSupplyDelegateBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }, {
        readonly internalType: "uint96";
        readonly name: "_amount";
        readonly type: "uint96";
    }];
    readonly name: "transfer";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const twabRewardsABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "_twabController";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint48";
        readonly name: "epochDuration";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint32";
        readonly name: "twabPeriodLength";
        readonly type: "uint32";
    }];
    readonly name: "EpochDurationNotMultipleOfTwabPeriod";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint64";
        readonly name: "epochEndTimestamp";
        readonly type: "uint64";
    }];
    readonly name: "EpochNotOver";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "epochExtension";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "currentEpochs";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "maxEpochs";
        readonly type: "uint8";
    }];
    readonly name: "ExceedsMaxEpochs";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "gracePeriodEndTimestamp";
        readonly type: "uint256";
    }];
    readonly name: "GracePeriodActive";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "epochId";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint8";
        readonly name: "numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "InvalidEpochId";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }];
    readonly name: "InvalidPromotion";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "creator";
        readonly type: "address";
    }];
    readonly name: "OnlyPromotionCreator";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PayeeZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }];
    readonly name: "PromotionInactive";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "epochId";
        readonly type: "uint8";
    }];
    readonly name: "RewardsAlreadyClaimed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint64";
        readonly name: "startTimePeriodOffset";
        readonly type: "uint64";
    }];
    readonly name: "StartTimeNotAlignedWithTwabPeriod";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "received";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "expected";
        readonly type: "uint256";
    }];
    readonly name: "TokensReceivedLessThanExpected";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TwabControllerZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroEpochDuration";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroEpochs";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroTokensPerEpoch";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "startTimestamp";
        readonly type: "uint64";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "tokensPerEpoch";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "epochDuration";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "PromotionDestroyed";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "epochNumber";
        readonly type: "uint8";
    }];
    readonly name: "PromotionEnded";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "numberOfEpochs";
        readonly type: "uint256";
    }];
    readonly name: "PromotionExtended";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8[]";
        readonly name: "epochIds";
        readonly type: "uint8[]";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "GRACE_PERIOD";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "claimRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_vault";
        readonly type: "address";
    }, {
        readonly internalType: "contract IERC20";
        readonly name: "_token";
        readonly type: "address";
    }, {
        readonly internalType: "uint64";
        readonly name: "_startTimestamp";
        readonly type: "uint64";
    }, {
        readonly internalType: "uint256";
        readonly name: "_tokensPerEpoch";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint48";
        readonly name: "_epochDuration";
        readonly type: "uint48";
    }, {
        readonly internalType: "uint8";
        readonly name: "_numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "createPromotion";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }];
    readonly name: "destroyPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_to";
        readonly type: "address";
    }];
    readonly name: "endPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_numberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "extendPromotion";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getCurrentEpochId";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getPromotion";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "creator";
            readonly type: "address";
        }, {
            readonly internalType: "uint64";
            readonly name: "startTimestamp";
            readonly type: "uint64";
        }, {
            readonly internalType: "uint8";
            readonly name: "numberOfEpochs";
            readonly type: "uint8";
        }, {
            readonly internalType: "address";
            readonly name: "vault";
            readonly type: "address";
        }, {
            readonly internalType: "uint48";
            readonly name: "epochDuration";
            readonly type: "uint48";
        }, {
            readonly internalType: "uint48";
            readonly name: "createdAt";
            readonly type: "uint48";
        }, {
            readonly internalType: "contract IERC20";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "tokensPerEpoch";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "rewardsUnclaimed";
            readonly type: "uint256";
        }];
        readonly internalType: "struct Promotion";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }];
    readonly name: "getRemainingRewards";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_promotionId";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8[]";
        readonly name: "_epochIds";
        readonly type: "uint8[]";
    }];
    readonly name: "getRewardsAmount";
    readonly outputs: readonly [{
        readonly internalType: "uint256[]";
        readonly name: "";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "data";
        readonly type: "bytes[]";
    }];
    readonly name: "multicall";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "results";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "twabController";
    readonly outputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const vaultABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name_";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "symbol_";
        readonly type: "string";
    }, {
        readonly internalType: "contract IERC4626";
        readonly name: "yieldVault_";
        readonly type: "address";
    }, {
        readonly internalType: "contract PrizePool";
        readonly name: "prizePool_";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "claimer_";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "yieldFeeRecipient_";
        readonly type: "address";
    }, {
        readonly internalType: "uint32";
        readonly name: "yieldFeePercentage_";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint256";
        readonly name: "yieldBuffer_";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "owner_";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [];
    readonly name: "BurnZeroShares";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "claimer";
        readonly type: "address";
    }];
    readonly name: "CallerNotClaimer";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "liquidationPair";
        readonly type: "address";
    }];
    readonly name: "CallerNotLP";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "yieldFeeRecipient";
        readonly type: "address";
    }];
    readonly name: "CallerNotYieldFeeRecipient";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ClaimRecipientZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ClaimerZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "DepositZeroAssets";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "asset";
        readonly type: "address";
    }];
    readonly name: "FailedToGetAssetDecimals";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "InvalidShortString";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "LPZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "LiquidationAmountOutZero";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "totalToWithdraw";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "availableYield";
        readonly type: "uint256";
    }];
    readonly name: "LiquidationExceedsAvailable";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "prizeToken";
        readonly type: "address";
    }];
    readonly name: "LiquidationTokenInNotPrizeToken";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "tokenOut";
        readonly type: "address";
    }];
    readonly name: "LiquidationTokenOutNotSupported";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "totalAssets";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "totalSupply";
        readonly type: "uint256";
    }];
    readonly name: "LossyDeposit";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "maxShares";
        readonly type: "uint256";
    }];
    readonly name: "MaxSharesExceeded";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "minAssets";
        readonly type: "uint256";
    }];
    readonly name: "MinAssetsNotReached";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "excess";
        readonly type: "uint256";
    }];
    readonly name: "MintLimitExceeded";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "MintZeroShares";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "OwnerZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly name: "PermitCallerNotOwner";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "PrizePoolZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "yieldFeeBalance";
        readonly type: "uint256";
    }];
    readonly name: "SharesExceedsYieldFeeBalance";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "str";
        readonly type: "string";
    }];
    readonly name: "StringTooLong";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "TwabControllerZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "WithdrawZeroAssets";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "yieldFeePercentage";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "maxYieldFeePercentage";
        readonly type: "uint256";
    }];
    readonly name: "YieldFeePercentageExceedsMax";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "YieldVaultZeroAddress";
    readonly type: "error";
}, {
    readonly inputs: readonly [];
    readonly name: "ZeroTotalAssets";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Approval";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "ClaimYieldFeeShares";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "claimer";
        readonly type: "address";
    }];
    readonly name: "ClaimerSet";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Deposit";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [];
    readonly name: "EIP712DomainChanged";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "tokenOut";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "liquidationPair";
        readonly type: "address";
    }];
    readonly name: "LiquidationPairSet";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "pendingOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipOffered";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "previousOwner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipTransferred";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }, {
        readonly components: readonly [{
            readonly internalType: "bool";
            readonly name: "useBeforeClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "bool";
            readonly name: "useAfterClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "contract IPrizeHooks";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly indexed: false;
        readonly internalType: "struct PrizeHooks";
        readonly name: "hooks";
        readonly type: "tuple";
    }];
    readonly name: "SetHooks";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Sponsor";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "liquidationPair";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "tokenOut";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amountOut";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "yieldFee";
        readonly type: "uint256";
    }];
    readonly name: "TransferYieldOut";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "receiver";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Withdraw";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "yieldFeePercentage";
        readonly type: "uint256";
    }];
    readonly name: "YieldFeePercentageSet";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "yieldFeeRecipient";
        readonly type: "address";
    }];
    readonly name: "YieldFeeRecipientSet";
    readonly type: "event";
}, {
    readonly inputs: readonly [];
    readonly name: "DOMAIN_SEPARATOR";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "FEE_PRECISION";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "HOOK_GAS";
    readonly outputs: readonly [{
        readonly internalType: "uint24";
        readonly name: "";
        readonly type: "uint24";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "MAX_YIELD_FEE";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }];
    readonly name: "allowance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "asset";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "availableYieldBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_account";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "claimOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_winner";
        readonly type: "address";
    }, {
        readonly internalType: "uint8";
        readonly name: "_tier";
        readonly type: "uint8";
    }, {
        readonly internalType: "uint32";
        readonly name: "_prizeIndex";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint96";
        readonly name: "_reward";
        readonly type: "uint96";
    }, {
        readonly internalType: "address";
        readonly name: "_rewardRecipient";
        readonly type: "address";
    }];
    readonly name: "claimPrize";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }];
    readonly name: "claimYieldFeeShares";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "claimer";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }];
    readonly name: "convertToAssets";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }];
    readonly name: "convertToShares";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "currentYieldBuffer";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "decimals";
    readonly outputs: readonly [{
        readonly internalType: "uint8";
        readonly name: "";
        readonly type: "uint8";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "subtractedValue";
        readonly type: "uint256";
    }];
    readonly name: "decreaseAllowance";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly name: "deposit";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_deadline";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "_v";
        readonly type: "uint8";
    }, {
        readonly internalType: "bytes32";
        readonly name: "_r";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes32";
        readonly name: "_s";
        readonly type: "bytes32";
    }];
    readonly name: "depositWithPermit";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "eip712Domain";
    readonly outputs: readonly [{
        readonly internalType: "bytes1";
        readonly name: "fields";
        readonly type: "bytes1";
    }, {
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "version";
        readonly type: "string";
    }, {
        readonly internalType: "uint256";
        readonly name: "chainId";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "verifyingContract";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "salt";
        readonly type: "bytes32";
    }, {
        readonly internalType: "uint256[]";
        readonly name: "extensions";
        readonly type: "uint256[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "getHooks";
    readonly outputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "bool";
            readonly name: "useBeforeClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "bool";
            readonly name: "useAfterClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "contract IPrizeHooks";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly internalType: "struct PrizeHooks";
        readonly name: "";
        readonly type: "tuple";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "addedValue";
        readonly type: "uint256";
    }];
    readonly name: "increaseAllowance";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_tokenOut";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_liquidationPair";
        readonly type: "address";
    }];
    readonly name: "isLiquidationPair";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_tokenOut";
        readonly type: "address";
    }];
    readonly name: "liquidatableBalanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "liquidationPair";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "maxDeposit";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "maxMint";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "maxRedeem";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "maxWithdraw";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }];
    readonly name: "mint";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "name";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly name: "nonces";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "pendingOwner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "deadline";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint8";
        readonly name: "v";
        readonly type: "uint8";
    }, {
        readonly internalType: "bytes32";
        readonly name: "r";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes32";
        readonly name: "s";
        readonly type: "bytes32";
    }];
    readonly name: "permit";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }];
    readonly name: "previewDeposit";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }];
    readonly name: "previewMint";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }];
    readonly name: "previewRedeem";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }];
    readonly name: "previewWithdraw";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "prizePool";
    readonly outputs: readonly [{
        readonly internalType: "contract PrizePool";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_minAssets";
        readonly type: "uint256";
    }];
    readonly name: "redeem";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_shares";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "redeem";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_claimer";
        readonly type: "address";
    }];
    readonly name: "setClaimer";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly internalType: "bool";
            readonly name: "useBeforeClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "bool";
            readonly name: "useAfterClaimPrize";
            readonly type: "bool";
        }, {
            readonly internalType: "contract IPrizeHooks";
            readonly name: "implementation";
            readonly type: "address";
        }];
        readonly internalType: "struct PrizeHooks";
        readonly name: "hooks";
        readonly type: "tuple";
    }];
    readonly name: "setHooks";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_liquidationPair";
        readonly type: "address";
    }];
    readonly name: "setLiquidationPair";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "_yieldFeePercentage";
        readonly type: "uint32";
    }];
    readonly name: "setYieldFeePercentage";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_yieldFeeRecipient";
        readonly type: "address";
    }];
    readonly name: "setYieldFeeRecipient";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "symbol";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "targetOf";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalAssets";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalDebt";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalPreciseAssets";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalYieldBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "transfer";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_newOwner";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_tokenOut";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountOut";
        readonly type: "uint256";
    }];
    readonly name: "transferTokensOut";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "twabController";
    readonly outputs: readonly [{
        readonly internalType: "contract TwabController";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_tokenIn";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_amountIn";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly name: "verifyTokensIn";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_maxShares";
        readonly type: "uint256";
    }];
    readonly name: "withdraw";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_assets";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_receiver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "withdraw";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "yieldBuffer";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "yieldFeeBalance";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "yieldFeePercentage";
    readonly outputs: readonly [{
        readonly internalType: "uint32";
        readonly name: "";
        readonly type: "uint32";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "yieldFeeRecipient";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "yieldVault";
    readonly outputs: readonly [{
        readonly internalType: "contract IERC4626";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const vaultFactoryABI: readonly [{
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "contract PrizeVault";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC4626";
        readonly name: "yieldVault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "contract PrizePool";
        readonly name: "prizePool";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly indexed: false;
        readonly internalType: "string";
        readonly name: "symbol";
        readonly type: "string";
    }];
    readonly name: "NewPrizeVault";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "allVaults";
    readonly outputs: readonly [{
        readonly internalType: "contract PrizeVault";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "_name";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "_symbol";
        readonly type: "string";
    }, {
        readonly internalType: "contract IERC4626";
        readonly name: "_yieldVault";
        readonly type: "address";
    }, {
        readonly internalType: "contract PrizePool";
        readonly name: "_prizePool";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_claimer";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "_yieldFeeRecipient";
        readonly type: "address";
    }, {
        readonly internalType: "uint32";
        readonly name: "_yieldFeePercentage";
        readonly type: "uint32";
    }, {
        readonly internalType: "uint256";
        readonly name: "_yieldBuffer";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "_owner";
        readonly type: "address";
    }];
    readonly name: "deployVault";
    readonly outputs: readonly [{
        readonly internalType: "contract PrizeVault";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }];
    readonly name: "deployedVaults";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "deployedByFactory";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "deployer";
        readonly type: "address";
    }];
    readonly name: "deployerNonces";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "nonce";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "totalVaults";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

declare const zapRouterABI: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_permit2";
        readonly type: "address";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "target";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "callData";
        readonly type: "bytes";
    }];
    readonly name: "CallFailed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }];
    readonly name: "CallerNotZap";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }];
    readonly name: "EtherTransferFailed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "balance";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "relayValue";
        readonly type: "uint256";
    }];
    readonly name: "InsufficientRelayValue";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }];
    readonly name: "InvalidCaller";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "minAmountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "balance";
        readonly type: "uint256";
    }];
    readonly name: "Slippage";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "target";
        readonly type: "address";
    }];
    readonly name: "TargetingInvalidContract";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Input[]";
            readonly name: "inputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "minOutputAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Output[]";
            readonly name: "outputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "target";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "value";
                readonly type: "uint256";
            }, {
                readonly internalType: "bytes";
                readonly name: "data";
                readonly type: "bytes";
            }];
            readonly internalType: "struct IBeefyZapRouter.Relay";
            readonly name: "relay";
            readonly type: "tuple";
        }, {
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }];
        readonly indexed: true;
        readonly internalType: "struct IBeefyZapRouter.Order";
        readonly name: "order";
        readonly type: "tuple";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }];
    readonly name: "FulfilledOrder";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "previousOwner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipTransferred";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "Paused";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "target";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes";
        readonly name: "data";
        readonly type: "bytes";
    }];
    readonly name: "RelayData";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "TokenReturned";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "Unpaused";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IPermit2.TokenPermissions[]";
            readonly name: "permitted";
            readonly type: "tuple[]";
        }, {
            readonly internalType: "uint256";
            readonly name: "nonce";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "deadline";
            readonly type: "uint256";
        }];
        readonly internalType: "struct IPermit2.PermitBatchTransferFrom";
        readonly name: "_permit";
        readonly type: "tuple";
    }, {
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Input[]";
            readonly name: "inputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "minOutputAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Output[]";
            readonly name: "outputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "target";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "value";
                readonly type: "uint256";
            }, {
                readonly internalType: "bytes";
                readonly name: "data";
                readonly type: "bytes";
            }];
            readonly internalType: "struct IBeefyZapRouter.Relay";
            readonly name: "relay";
            readonly type: "tuple";
        }, {
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }];
        readonly internalType: "struct IBeefyZapRouter.Order";
        readonly name: "_order";
        readonly type: "tuple";
    }, {
        readonly internalType: "bytes";
        readonly name: "_signature";
        readonly type: "bytes";
    }, {
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "int32";
                readonly name: "index";
                readonly type: "int32";
            }];
            readonly internalType: "struct IBeefyZapRouter.StepToken[]";
            readonly name: "tokens";
            readonly type: "tuple[]";
        }];
        readonly internalType: "struct IBeefyZapRouter.Step[]";
        readonly name: "_route";
        readonly type: "tuple[]";
    }];
    readonly name: "executeOrder";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly components: readonly [{
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "amount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Input[]";
            readonly name: "inputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "minOutputAmount";
                readonly type: "uint256";
            }];
            readonly internalType: "struct IBeefyZapRouter.Output[]";
            readonly name: "outputs";
            readonly type: "tuple[]";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "target";
                readonly type: "address";
            }, {
                readonly internalType: "uint256";
                readonly name: "value";
                readonly type: "uint256";
            }, {
                readonly internalType: "bytes";
                readonly name: "data";
                readonly type: "bytes";
            }];
            readonly internalType: "struct IBeefyZapRouter.Relay";
            readonly name: "relay";
            readonly type: "tuple";
        }, {
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "recipient";
            readonly type: "address";
        }];
        readonly internalType: "struct IBeefyZapRouter.Order";
        readonly name: "_order";
        readonly type: "tuple";
    }, {
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "target";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "value";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes";
            readonly name: "data";
            readonly type: "bytes";
        }, {
            readonly components: readonly [{
                readonly internalType: "address";
                readonly name: "token";
                readonly type: "address";
            }, {
                readonly internalType: "int32";
                readonly name: "index";
                readonly type: "int32";
            }];
            readonly internalType: "struct IBeefyZapRouter.StepToken[]";
            readonly name: "tokens";
            readonly type: "tuple[]";
        }];
        readonly internalType: "struct IBeefyZapRouter.Step[]";
        readonly name: "_route";
        readonly type: "tuple[]";
    }];
    readonly name: "executeOrder";
    readonly outputs: readonly [];
    readonly stateMutability: "payable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "pause";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "paused";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "permit2";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "tokenManager";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "unpause";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly stateMutability: "payable";
    readonly type: "receive";
}];

declare const zapTokenManagerABI: readonly [{
    readonly inputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "target";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "callData";
        readonly type: "bytes";
    }];
    readonly name: "CallFailed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }];
    readonly name: "CallerNotZap";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }];
    readonly name: "EtherTransferFailed";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "balance";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "relayValue";
        readonly type: "uint256";
    }];
    readonly name: "InsufficientRelayValue";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "caller";
        readonly type: "address";
    }];
    readonly name: "InvalidCaller";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "minAmountOut";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "balance";
        readonly type: "uint256";
    }];
    readonly name: "Slippage";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "target";
        readonly type: "address";
    }];
    readonly name: "TargetingInvalidContract";
    readonly type: "error";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "_user";
        readonly type: "address";
    }, {
        readonly components: readonly [{
            readonly internalType: "address";
            readonly name: "token";
            readonly type: "address";
        }, {
            readonly internalType: "uint256";
            readonly name: "amount";
            readonly type: "uint256";
        }];
        readonly internalType: "struct IBeefyZapRouter.Input[]";
        readonly name: "_inputs";
        readonly type: "tuple[]";
    }];
    readonly name: "pullTokens";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "zap";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}];

/**
 * Shortens a hash into something a little more user friendly
 * @param hash hash string to shorten
 * @param options formatting options
 * @returns shortened, user-friendly string
 */
declare const shorten: (hash: string, options?: {
    short?: boolean;
}) => string | null;
/**
 * Returns a typecasted lowercase address
 * @param address original address
 * @returns
 */
declare const lower: (address: string) => `0x${Lowercase<string>}`;

/**
 * Returns a block explorer URL for the given token/address/tx/block
 * @param chainId the chain ID for the block explorer
 * @param value value to append to URL (token address, transaction hash, block number, etc.)
 * @param type value type (default is 'address')
 * @returns
 */
declare const getBlockExplorerUrl: (chainId: number, value: string, type?: 'address' | 'token' | 'tx' | 'block') => string;
declare const getBlockExplorerName: (chainId: number) => string;

/**
 * Returns a block within a range of a given timestamp
 * @dev adapted from https://github.com/trmid/block-at-timestamp
 *
 * @param publicClient a public Viem client for the chain that should be queried
 * @param timestamp target timestamp in seconds
 * @param range target timestamp range in seconds (default is `60`)
 * @returns
 */
declare const getBlockAtTimestamp: (publicClient: PublicClient, timestamp: bigint, range?: number) => Promise<{
    number: bigint;
    timestamp: bigint;
    nonce: `0x${string}`;
    hash: `0x${string}`;
    logsBloom: `0x${string}`;
    baseFeePerGas: bigint | null;
    blobGasUsed: bigint;
    difficulty: bigint;
    excessBlobGas: bigint;
    extraData: `0x${string}`;
    gasLimit: bigint;
    gasUsed: bigint;
    miner: `0x${string}`;
    mixHash: `0x${string}`;
    parentBeaconBlockRoot?: `0x${string}` | undefined;
    parentHash: `0x${string}`;
    receiptsRoot: `0x${string}`;
    sealFields: `0x${string}`[];
    sha3Uncles: `0x${string}`;
    size: bigint;
    stateRoot: `0x${string}`;
    totalDifficulty: bigint | null;
    transactionsRoot: `0x${string}`;
    uncles: `0x${string}`[];
    withdrawals?: viem.Withdrawal[] | undefined;
    withdrawalsRoot?: `0x${string}` | undefined;
    transactions: `0x${string}`[];
}>;

/**
 * Network IDs
 */
declare enum NETWORK {
    mainnet = 1,
    sepolia = 11155111,
    bsc = 56,
    bsc_testnet = 97,
    polygon = 137,
    mumbai = 80001,
    optimism = 10,
    optimism_sepolia = 11155420,
    avalanche = 43114,
    fuji = 43113,
    celo = 42220,
    celo_testnet = 44787,
    arbitrum = 42161,
    arbitrum_sepolia = 421614,
    base = 8453,
    base_sepolia = 84532,
    scroll = 534352,
    scroll_sepolia = 534351,
    gnosis = 100,
    gnosis_chiado = 10200,
    world = 480,
    world_sepolia = 4801
}
type NETWORK_NAME = keyof typeof NETWORK;
/**
 * POOL token addresses
 */
declare const POOL_TOKEN_ADDRESSES: {
    readonly 1: "0x0cEC1A9154Ff802e7934Fc916Ed7Ca50bDE6844e";
    readonly 137: "0x25788a1a171ec66Da6502f9975a15B609fF54CF6";
    readonly 10: "0x395ae52bb17aef68c2888d941736a71dc6d4e125";
    readonly 42161: "0xCF934E2402A5e072928a39a956964eb8F2B5B79C";
    readonly 8453: "0xd652C5425aea2Afd5fb142e120FeCf79e18fafc3";
    readonly 534352: "0xF9Af83FC41e0cc2af2fba93644D542Df6eA0F2b7";
    readonly 100: "0x216a7d520992eD198593A16e0b17c784c9cdc660";
    readonly 480: "0x7077C71B4AF70737a08287E279B717Dcf64fdC57";
    readonly 11155420: "0x858EE6f08f4C501FB6CB8D7c14B599CaeCbdf964";
    readonly 421614: "0x02A32F041C16158bcC1CaA90e22B230958eD5c4b";
    readonly 84532: "0x50Ac98a0CA373a3935069A8755D895663d2F4A16";
    readonly 534351: "0x7026b77376547Ba7961C16a4A05edaE070aBeC47";
    readonly 10200: "0xa83a315bed18b36308a518c7f77a2464e9f7286c";
};
/**
 * USDC token addresses
 */
declare const USDC_TOKEN_ADDRESSES: {
    [chainId: number]: Lowercase<Address>;
};
/**
 * Prize Pools
 */
declare const PRIZE_POOLS: {
    chainId: NETWORK;
    address: Address;
    options: {
        prizeTokenAddress: Address;
        drawManagerAddress: Address;
        twabControllerAddress: Address;
        drawPeriodInSeconds: number;
        drawAuctionDurationInSeconds: number;
        tierShares: number;
        reserveShares: number;
    };
}[];
/**
 * Stablecoin addresses and their corresponding fiat currency
 */
declare const STABLECOINS: Record<NETWORK, {
    [address: Lowercase<Address>]: string;
}>;
/**
 * Dolphin address
 */
declare const DOLPHIN_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
/**
 * Dead address
 */
declare const DEAD_ADDRESS = "0x000000000000000000000000000000000000dead";
/**
 * Optimism gas oracle address
 */
declare const OP_GAS_ORACLE_ADDRESS = "0x420000000000000000000000000000000000000f";
/**
 * Native assets' info
 */
declare const NATIVE_ASSETS: Record<NETWORK, Token>;
/**
 * Wrapped native asset addresses (example: WETH, WMATIC, etc.)
 */
declare const WRAPPED_NATIVE_ASSETS: Record<NETWORK, Lowercase<Address> | null>;
/**
 * TWAB rewards addresses
 */
declare const TWAB_REWARDS_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Pool-Wide TWAB rewards addresses
 */
declare const POOL_WIDE_TWAB_REWARDS_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Vault factory addresses
 */
declare const VAULT_FACTORY_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Liquidation pair factory addresses
 */
declare const LIQUIDATION_PAIR_FACTORY_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Default claimer addresses
 */
declare const DEFAULT_CLAIMER_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Liquidation router addresses
 */
declare const LIQUIDATION_ROUTER_ADDRESSES: {
    [chainId: number]: Address;
};
/**
 * Subgraph API URLs
 */
declare const SUBGRAPH_API_URLS: {
    readonly 1: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-ethereum/v0.0.2/gn";
    readonly 10: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-optimism/v0.0.4/gn";
    readonly 8453: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-base/v0.0.1/gn";
    readonly 42161: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-arbitrum-one/v0.0.1/gn";
    readonly 534352: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-scroll/v0.0.1/gn";
    readonly 100: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-gnosis/v0.0.1/gn";
    readonly 480: "https://api.goldsky.com/api/public/project_cm3xb1e8iup5601yx9mt5caat/subgraphs/pt-v5-world/v0.0.1/gn";
    readonly 11155420: "https://api.studio.thegraph.com/query/63100/pt-v5-op-sepolia/version/latest";
    readonly 421614: "https://api.studio.thegraph.com/query/63100/pt-v5-arbitrum-sepolia/version/latest";
    readonly 84532: "https://api.studio.thegraph.com/query/63100/pt-v5-base-sepolia/version/latest";
    readonly 534351: "https://api.studio.thegraph.com/query/63100/pt-v5-scroll-sepolia/version/latest";
    readonly 10200: "https://api.studio.thegraph.com/query/63100/pt-v5-gnosis-chiado/version/latest";
};
/**
 * Token Prices API URL
 */
declare const TOKEN_PRICES_API_URL = "https://token-prices.api.cabana.fi";
/**
 * Networks supported by the price caching API
 */
declare const TOKEN_PRICE_API_SUPPORTED_NETWORKS: NETWORK[];
/**
 * Redirects for tokens without pricing data on the caching API
 */
declare const TOKEN_PRICE_REDIRECTS: {
    [chainId: number]: {
        [address: Lowercase<Address>]: {
            chainId: number;
            address: Lowercase<Address>;
        };
    };
};
/**
 * Redirects for offchain token rebrandings
 */
declare const TOKEN_DATA_REDIRECTS: {
    [chainId: number]: {
        [address: Lowercase<Address>]: {
            name?: string;
            symbol?: string;
        };
    };
};
/**
 * Zap settings
 */
declare const ZAP_SETTINGS: {
    [chainId: number]: {
        zapRouter: Address;
        zapTokenManager: Address;
    };
};
/**
 * Velodrome addresses
 */
declare const VELODROME_ADDRESSES: {
    [chainId: number]: {
        router: Address;
        lpFactories: Lowercase<Address>[];
    };
};
/**
 * Domains
 */
declare const DOMAINS: {
    readonly app: "https://app.cabana.fi";
    readonly app_v4: "https://app.pooltogether.com";
    readonly landingPage: "https://cabana.fi";
    readonly protocolLandingPage: "https://pooltogether.com";
    readonly docs: "https://docs.cabana.fi";
    readonly protocolDocs: "https://docs.pooltogether.com";
    readonly protocolDevDocs: "https://dev.pooltogether.com";
    readonly governance: "https://gov.pooltogether.com";
    readonly poolExplorer: "https://poolexplorer.win";
    readonly tools_v4: "https://tools.pooltogether.com";
    readonly notion: "https://pooltogetherdao.notion.site";
    readonly vaultListCreator: "https://lists.cabana.fi";
    readonly vaultFactory: "https://factory.cabana.fi";
    readonly analytics: "https://analytics.cabana.fi";
    readonly swaps: "https://swap.cabana.fi";
    readonly rewardsBuilder: "https://rewards.cabana.fi";
    readonly flashLiquidator: "https://flash.cabana.fi";
    readonly migrations: "https://migrate.cabana.fi";
    readonly builders: "https://builders.cabana.fi";
};
/**
 * Links
 */
declare const LINKS: {
    readonly termsOfService: "https://cabana.fi/terms";
    readonly privacyPolicy: "https://cabana.fi/privacy";
    readonly ecosystem: "https://pooltogether.com/ecosystem";
    readonly discord: "https://pooltogether.com/discord";
    readonly appDocs: "https://docs.cabana.fi/#the-cabana-app";
    readonly toolDocs: "https://docs.cabana.fi/#cabana-tools";
    readonly protocolBasicsDocs: "https://docs.cabana.fi/protocol/the-basics";
    readonly delegateDocs: "https://docs.cabana.fi/cabana-app/delegation";
    readonly prizeYieldDocs: "https://docs.cabana.fi/cabana-app/prize-yield";
    readonly factoryDocs: "https://docs.cabana.fi/cabana-tools/cabana-factory";
    readonly listDocs: "https://docs.cabana.fi/cabana-tools/cabana-lists";
    readonly analyticsDocs: "https://docs.cabana.fi/cabana-tools/cabanalytics";
    readonly swapDocs: "https://docs.cabana.fi/cabana-tools/cabana-swaps";
    readonly flashDocs: "https://docs.cabana.fi/cabana-tools/cabana-flash";
    readonly appGuides: "https://docs.cabana.fi/cabana-app/guides";
    readonly toolGuides: "https://docs.cabana.fi/cabana-tools/guides";
    readonly protocolFaqs: "https://docs.cabana.fi/protocol/faqs";
    readonly appFaqs: "https://docs.cabana.fi/cabana-app/faqs";
    readonly toolFaqs: "https://docs.cabana.fi/cabana-tools/faqs";
    readonly rewardTokenWhitelist: "https://docs.cabana.fi/cabana-app/bonus-rewards#reward-token-whitelist";
    readonly risks: "https://docs.pooltogether.com/security/risks";
    readonly audits: "https://docs.pooltogether.com/security/audits";
    readonly devDocs_v4: "https://dev.pooltogether.com/protocol/V4/introduction";
    readonly depositDelegator: "https://tools.pooltogether.com/delegate";
    readonly prizeTierController: "https://tools.pooltogether.com/prize-tier-controller";
    readonly communityCalendar: "https://pooltogetherdao.notion.site/Community-Calendar-4ce3024241dd464db96215e6729a78e0";
    readonly brandKit: "https://www.figma.com/community/file/1212805243917604494";
    readonly twitter: "https://twitter.com/PoolTogether_";
    readonly github: "https://github.com/orgs/GenerationSoftware/repositories?q=pooltogether+sort%3Astars";
    readonly medium: "https://medium.com/pooltogether";
    readonly tally: "https://www.tally.xyz/gov/pooltogether";
    readonly treasury: "https://info.pooltogether.com/treasury";
    readonly dune_v4: "https://dune.com/sarfang/PoolTogetherV4";
    readonly grants: "https://poolgrants.org";
    readonly hey: "https://hey.xyz/u/pooltogether";
    readonly mirror: "https://pooltogether.mirror.xyz/";
    readonly warpcast: "https://warpcast.com/~/channel/pool-together";
    readonly clientJs: "https://www.npmjs.com/package/@generationsoftware/hyperstructure-client-js";
    readonly clientJs_v4: "https://www.npmjs.com/package/@pooltogether/v4-client-js";
    readonly reactHooks: "https://www.npmjs.com/package/@generationsoftware/hyperstructure-react-hooks";
    readonly app: "https://app.cabana.fi";
    readonly app_v4: "https://app.pooltogether.com";
    readonly landingPage: "https://cabana.fi";
    readonly protocolLandingPage: "https://pooltogether.com";
    readonly docs: "https://docs.cabana.fi";
    readonly protocolDocs: "https://docs.pooltogether.com";
    readonly protocolDevDocs: "https://dev.pooltogether.com";
    readonly governance: "https://gov.pooltogether.com";
    readonly poolExplorer: "https://poolexplorer.win";
    readonly tools_v4: "https://tools.pooltogether.com";
    readonly notion: "https://pooltogetherdao.notion.site";
    readonly vaultListCreator: "https://lists.cabana.fi";
    readonly vaultFactory: "https://factory.cabana.fi";
    readonly analytics: "https://analytics.cabana.fi";
    readonly swaps: "https://swap.cabana.fi";
    readonly rewardsBuilder: "https://rewards.cabana.fi";
    readonly flashLiquidator: "https://flash.cabana.fi";
    readonly migrations: "https://migrate.cabana.fi";
    readonly builders: "https://builders.cabana.fi";
};
/**
 * Block explorer mapping
 */
declare const BLOCK_EXPLORERS: Record<NETWORK, {
    name: string;
    url: string;
}>;
/**
 * CoinGecko API URL
 */
declare const COINGECKO_API_URL = "https://api.coingecko.com/api/v3";
/**
 * CoinGecko platform IDs
 */
declare const COINGECKO_PLATFORMS: {
    readonly 1: "ethereum";
    readonly 56: "binance-smart-chain";
    readonly 137: "polygon-pos";
    readonly 10: "optimistic-ethereum";
    readonly 43114: "avalanche";
    readonly 42220: "celo";
    readonly 42161: "arbitrum-one";
    readonly 8453: "base";
    readonly 534352: "scroll";
    readonly 100: "xdai";
};
type COINGECKO_PLATFORM = keyof typeof COINGECKO_PLATFORMS;
/**
 * CoinGecko native token IDs
 */
declare const COINGECKO_NATIVE_TOKEN_IDS: Record<NETWORK, string>;
/**
 * Second constants
 */
declare const SECONDS_PER_MINUTE = 60;
declare const SECONDS_PER_HOUR = 3600;
declare const SECONDS_PER_DAY = 86400;
declare const SECONDS_PER_WEEK = 604800;
declare const SECONDS_PER_MONTH = 2628000;
declare const SECONDS_PER_YEAR = 31536000;
/**
 * Minute constants
 */
declare const MINUTES_PER_HOUR = 60;
declare const MINUTES_PER_DAY = 1440;
/**
 * Max uint256 value
 */
declare const MAX_UINT_256: bigint;
/**
 * Max uint96 value
 */
declare const MAX_UINT_96: bigint;
/**
 * EIP2612 Permit Types
 */
declare const EIP2612_PERMIT_TYPES: {
    readonly Permit: readonly [{
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly name: "nonce";
        readonly type: "uint256";
    }, {
        readonly name: "deadline";
        readonly type: "uint256";
    }];
};
/**
 * Old DAI Permit Types
 */
declare const OLD_DAI_PERMIT_TYPES: {
    readonly Permit: readonly [{
        readonly name: "holder";
        readonly type: "address";
    }, {
        readonly name: "spender";
        readonly type: "address";
    }, {
        readonly name: "nonce";
        readonly type: "uint256";
    }, {
        readonly name: "expiry";
        readonly type: "uint256";
    }, {
        readonly name: "allowed";
        readonly type: "bool";
    }];
};

/**
 * Returns all native token prices from CoinGecko
 *
 * NOTE: `ids` can be found through `COINGECKO_NATIVE_TOKEN_IDS`
 * @param currencies optional currency override (default is ['eth'])
 * @returns
 */
declare const getCoingeckoSimpleTokenPrices: (currencies?: string[]) => Promise<CoingeckoTokenPrices>;
/**
 * Returns token prices from CoinGecko from provided token addresses on a given chain
 *
 * NOTE: Contract addresses returned are all lowercase
 * @param chainId chain ID where the token addresses provided are from
 * @param tokenAddresses token addresses to query prices for
 * @param currencies optional currency override (default is ['eth'])
 * @returns
 */
declare const getCoingeckoTokenPrices: (chainId: COINGECKO_PLATFORM, tokenAddresses: string[], currencies?: string[]) => Promise<CoingeckoTokenPrices>;
/**
 * Returns a token's price from an object of many CoinGecko token prices
 * @param chainId chain ID for the token requested
 * @param tokenAddress the token's address
 * @param tokenPrices all token prices returned from CoinGecko
 * @param currency optional currency override (default is 'eth')
 * @returns
 */
declare const getTokenPriceFromObject: (chainId: number, tokenAddress: string, tokenPrices: {
    [chainId: number]: CoingeckoTokenPrices;
} | undefined, currency?: string) => number | undefined;
/**
 * Returns token data from CoinGecko
 * @param chainId chain ID where the token address provided is from
 * @param tokenAddress token address to query token data for
 * @returns
 */
declare const getCoingeckoTokenData: (chainId: COINGECKO_PLATFORM, tokenAddress: string) => Promise<CoingeckoTokenData | undefined>;
/**
 * Returns exchange rates from CoinGecko
 * @returns
 */
declare const getCoingeckoExchangeRates: () => Promise<CoingeckoExchangeRates>;

/**
 * Returns a converted and formatted currency value in string form
 *
 * NOTE: Assumes 'eth' as `baseCurrency` unless otherwise specified through `options`
 * @param baseValue a currency value to convert and format
 * @param currency the currency to convert to
 * @param exchangeRates currency exchange rates to refer to
 * @param options formatting and base currency options
 * @returns
 */
declare const formatCurrencyValue: (baseValue: number | string, currency: string, exchangeRates: CoingeckoExchangeRates, options?: Omit<Intl.NumberFormatOptions, 'style' | 'currency'> & {
    baseCurrency?: string;
    locale?: string;
    round?: boolean;
    hideZeroes?: boolean;
    shortenMillions?: boolean;
}) => string | undefined;
/**
 * Returns a currency value converted to another currency
 *
 * NOTE: Assumes 'eth' as `baseCurrency` unless otherwise specified through `options`
 * @param baseValue a currency value to convert
 * @param currency the currency to convert to
 * @param exchangeRates currency exchange rates to refer to
 * @param options optional settings
 * @returns
 */
declare const calculateCurrencyValue: (baseValue: number | string, currency: string, exchangeRates: CoingeckoExchangeRates, options?: {
    baseCurrency?: string;
}) => number | undefined;

/**
 * Returns a valid Discord invite key from a given hCaptcha token
 * @param token - valid hCaptcha token
 */
declare const getDiscordInvite: (token: string) => Promise<void>;

declare const depositEventABI: {
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Deposit";
    readonly type: "event";
};
/**
 * Returns `Deposit` events
 * @param publicClient a public Viem client to query through
 * @param vaultAddresses vault addresses to get events for
 * @param options optional settings
 * @returns
 */
declare const getDepositEvents: (publicClient: PublicClient, vaultAddresses: Address[], options?: {
    sender?: Address[];
    owner?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<typeof depositEventABI, [typeof depositEventABI], true>>;
/**
 * Returns `Withdraw` events
 * @param publicClient a public Viem client to query through
 * @param vaultAddresses vault addresses to get events for
 * @param options optional settings
 * @returns
 */
declare const getWithdrawEvents: (publicClient: PublicClient, vaultAddresses: Address[], options?: {
    sender?: Address[];
    receiver?: Address[];
    owner?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "receiver";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Withdraw";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "receiver";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "assets";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "shares";
        readonly type: "uint256";
    }];
    readonly name: "Withdraw";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `DrawStarted` events from a draw manager contract
 * @param publicClient a public Viem client to query through
 * @param drawManagerAddress the address of a prize pool's draw manager to query events for
 * @param options optional settings
 * @returns
 */
declare const getDrawStartedEvents: (publicClient: PublicClient, drawManagerAddress: Address, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint32";
        readonly name: "rngRequestId";
        readonly type: "uint32";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "count";
        readonly type: "uint64";
    }];
    readonly name: "DrawStarted";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint32";
        readonly name: "rngRequestId";
        readonly type: "uint32";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "count";
        readonly type: "uint64";
    }];
    readonly name: "DrawStarted";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `DrawAwarded` events from a prize pool contract
 * @param publicClient a public Viem client to query through
 * @param prizePoolAddress the address of a prize pool to query events for
 * @param options optional settings
 * @returns
 */
declare const getDrawAwardedEvents: (publicClient: PublicClient, prizePoolAddress: Address, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "winningRandomNumber";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "lastNumTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "reserve";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint128";
        readonly name: "prizeTokensPerShare";
        readonly type: "uint128";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "drawOpenedAt";
        readonly type: "uint48";
    }];
    readonly name: "DrawAwarded";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "winningRandomNumber";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "lastNumTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "numTiers";
        readonly type: "uint8";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "reserve";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint128";
        readonly name: "prizeTokensPerShare";
        readonly type: "uint128";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "drawOpenedAt";
        readonly type: "uint48";
    }];
    readonly name: "DrawAwarded";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `DrawFinished` events from a draw manager contract
 * @param publicClient a public Viem client to query through
 * @param drawManagerAddress the address of a prize pool's draw manager to query events for
 * @param options optional settings
 * @returns
 */
declare const getDrawFinishedEvents: (publicClient: PublicClient, drawManagerAddress: Address, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "contribution";
        readonly type: "uint256";
    }];
    readonly name: "DrawFinished";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "sender";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "recipient";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "elapsedTime";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "reward";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "contribution";
        readonly type: "uint256";
    }];
    readonly name: "DrawFinished";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `SwappedExactAmountOut` events
 * @param publicClient a public Viem client to query through
 * @param options optional settings
 * @returns
 */
declare const getLiquidationEvents: (publicClient: PublicClient, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<{
    address: Address;
    args: {
        amountIn: bigint;
        amountInMax: bigint;
        amountOut: bigint;
        sender: Address;
        receiver: Address;
        liquidationPair: Address;
    };
    blockNumber: bigint;
    logIndex: number;
    transactionHash: `0x${string}`;
}[]>;
/**
 * Returns `ContributePrizeTokens` events
 * @param publicClient a public Viem client to query through
 * @param prizePoolAddress the address of the prize pool to query events for
 * @param options optional settings (recommended `vaultAddress` param)
 * @returns
 */
declare const getVaultContributionEvents: (publicClient: PublicClient, prizePoolAddress: Address, options?: {
    vaultAddress?: Address;
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributePrizeTokens";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint24";
        readonly name: "drawId";
        readonly type: "uint24";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributePrizeTokens";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `ContributedReserve` events
 * @param publicClient a public Viem client to query through
 * @param prizePoolAddress the address of the prize pool to query events for
 * @param options optional settings
 * @returns
 */
declare const getManualContributionEvents: (publicClient: PublicClient, prizePoolAddress: Address, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributedReserve";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ContributedReserve";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `ReserveConsumed` events
 * @param publicClient a public Viem client to query through
 * @param prizePoolAddress the address of the prize pool to query events for
 * @param options optional settings
 * @returns
 */
declare const getPrizeBackstopEvents: (publicClient: PublicClient, prizePoolAddress: Address, options?: {
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ReserveConsumed";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "ReserveConsumed";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `Transfer` events for a given token
 * @param publicClient a public Viem client to query through
 * @param tokenAddress the token address to query transfers for
 * @param options optional settings
 * @returns
 */
declare const getTokenTransferEvents: (publicClient: PublicClient, tokenAddress: Address, options?: {
    from?: Address[];
    to?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "value";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `PromotionCreated` events
 * @param publicClient a public Viem client to query through
 * @param options optional settings
 * @returns
 */
declare const getPromotionCreatedEvents: (publicClient: PublicClient, options?: {
    promotionIds?: bigint[];
    vaultAddresses?: Address[];
    tokenAddresses?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
    twabRewardsAddress?: Address;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "startTimestamp";
        readonly type: "uint64";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "tokensPerEpoch";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "epochDuration";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint64";
        readonly name: "startTimestamp";
        readonly type: "uint64";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "tokensPerEpoch";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint48";
        readonly name: "epochDuration";
        readonly type: "uint48";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns `RewardsClaimed` events
 * @param publicClient a public Viem client to query through
 * @param options optional settings
 * @returns
 */
declare const getPromotionRewardsClaimedEvents: (publicClient: PublicClient, options?: {
    promotionIds?: bigint[];
    userAddresses?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
    twabRewardsAddress?: Address;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8[]";
        readonly name: "epochIds";
        readonly type: "uint8[]";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8[]";
        readonly name: "epochIds";
        readonly type: "uint8[]";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns pool-wide `PromotionCreated` events
 * @param publicClient a public Viem client to query through
 * @param options optional settings
 * @returns
 */
declare const getPoolWidePromotionCreatedEvents: (publicClient: PublicClient, options?: {
    promotionIds?: bigint[];
    tokenAddresses?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "startTimestamp";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "tokensPerEpoch";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "epochDuration";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "contract IERC20";
        readonly name: "token";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "startTimestamp";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint104";
        readonly name: "tokensPerEpoch";
        readonly type: "uint104";
    }, {
        readonly indexed: false;
        readonly internalType: "uint40";
        readonly name: "epochDuration";
        readonly type: "uint40";
    }, {
        readonly indexed: false;
        readonly internalType: "uint8";
        readonly name: "initialNumberOfEpochs";
        readonly type: "uint8";
    }];
    readonly name: "PromotionCreated";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;
/**
 * Returns pool-wide `RewardsClaimed` events
 * @param publicClient a public Viem client to query through
 * @param options optional settings
 * @returns
 */
declare const getPoolWidePromotionRewardsClaimedEvents: (publicClient: PublicClient, options?: {
    promotionIds?: bigint[];
    userAddresses?: Address[];
    vaultAddresses?: Address[];
    fromBlock?: bigint;
    toBlock?: bigint;
}) => Promise<GetLogsReturnType<{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes32";
        readonly name: "epochClaimFlags";
        readonly type: "bytes32";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}, [{
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "promotionId";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes32";
        readonly name: "epochClaimFlags";
        readonly type: "bytes32";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "vault";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "amount";
        readonly type: "uint256";
    }];
    readonly name: "RewardsClaimed";
    readonly type: "event";
}], true, bigint | undefined, bigint | "latest">>;

/**
 * Formats a number string to the requested precision
 * @param val number string (ex. "1005.2924")
 * @param precision precision to format to (default is 2)
 * @returns
 */
declare const formatStringWithPrecision: (val: string, precision?: number) => string;
/**
 * Formats a number to make it legible & user-friendly
 * @param val number to format
 * @param options formatting options
 * @returns
 */
declare const formatNumberForDisplay: (val: string | number | bigint, options?: Intl.NumberFormatOptions & {
    locale?: string;
    round?: boolean;
    hideZeroes?: boolean;
    shortenMillions?: boolean;
}) => string;
/**
 * Wraps {@link formatNumberForDisplay} and handles shifting decimals of a BigInt
 * @param val BigInt to format
 * @param decimals decimals to shift by
 * @param options formatting options
 * @returns
 */
declare const formatBigIntForDisplay: (val: bigint, decimals: number, options?: Intl.NumberFormatOptions & {
    locale?: string;
    round?: boolean;
    hideZeroes?: boolean;
}) => string;
/**
 * Wraps {@link formatNumberForDisplay} and handles currency style selection
 * @param val number to format
 * @param currency currency symbol and formatting to follow (default is "USD")
 * @param options formatting options
 * @returns
 */
declare const formatCurrencyNumberForDisplay: (val: string | number, currency?: string, options?: Omit<Intl.NumberFormatOptions, 'style' | 'currency'> & {
    locale?: string;
    round?: boolean;
    hideZeroes?: boolean;
    shortenMillions?: boolean;
}) => string;
/**
 * Returns the number of digits after a decimal place
 * @param val number to check max precision for
 * @returns
 */
declare const getMaxPrecision: (val: number) => number;

/**
 * Returns an estimated gas fee (in wei) for a given contract transaction
 * @dev if your transaction is expected to fail, manually pass in a `gasAmount`
 * @param publicClient a public Viem client to query through
 * @param tx the transaction to estimate gas fees for
 * @param options optional settings
 * @returns
 */
declare const getGasFeeEstimate: (publicClient: PublicClient, tx: {
    address: Address;
    abi: Abi;
    functionName: string;
    args?: any[];
    account?: Address;
}, options?: {
    gasAmount?: bigint;
}) => Promise<bigint>;

/**
 * Returns liquidation pair addresses
 * @param publicClient a public Viem client to query through
 * @returns
 */
declare const getLiquidationPairAddresses: (publicClient: PublicClient) => Promise<`0x${string}`[]>;

/**
 * Pads two BigInts with a set precision then divides them
 * @param a numerator for division
 * @param b denominator for division
 * @param precision precision for padding (default is 4)
 * @returns
 */
declare const divideBigInts: (a: bigint, b: bigint, precision?: number) => number;
/**
 * Calculates a percentage of a BigInt
 * @param bigint BigInt to calculate a percentage from
 * @param percentage percentage to calculate from BigInt (ex. 0.2)
 * @returns
 */
declare const calculatePercentageOfBigInt: (bigint: bigint, percentage: number) => bigint;
/**
 * Helper function to sort BigInts in ascending order
 * @param a first BigInt
 * @param b second BigInt
 * @returns
 */
declare const sortByBigIntAsc: (a: bigint, b: bigint) => 1 | 0 | -1;
/**
 * Helper function to sort BigInts in descending order
 * @param a first BigInt
 * @param b second BigInt
 * @returns
 */
declare const sortByBigIntDesc: (a: bigint, b: bigint) => 1 | 0 | -1;
/**
 * Returns the absolute value of a bigint
 * @param n bigint to get absolute value for
 * @returns
 */
declare const abs: (n: bigint) => bigint;

interface MulticallContract {
    address: Address;
    abi: Abi;
    functionName: string;
    args?: any[];
}
/**
 * Returns the results of a simple multicall where many calls are made to a single contract address
 * @param publicClient a public Viem client to query through
 * @param contractAddress contract address to make calls to
 * @param abi the ABI of the contract provided
 * @param calls the calls to make to the contract
 * @returns
 */
declare const getSimpleMulticallResults: (publicClient: PublicClient, contractAddress: Address, abi: Abi, calls: {
    functionName: string;
    args?: any[];
}[]) => Promise<any[]>;
/**
 * Returns the results of a multicall where each call is made to every contract address provided
 * @param publicClient a public Viem client to query through
 * @param contractAddresses contract addresses to make calls to
 * @param abi the ABI of the contracts provided
 * @param calls the calls to make to each contract
 * @returns
 */
declare const getMulticallResults: (publicClient: PublicClient, contractAddresses: Address[], abi: Abi, calls: {
    functionName: string;
    args?: any[];
}[]) => Promise<{
    [contractAddress: `0x${string}`]: {
        [functionName: string]: any;
    };
}>;
/**
 * Returns the results of a complex multicall where full call data is provided
 * @param publicClient a public Viem client to query through
 * @param calls the calls to make
 * @returns
 */
declare const getComplexMulticallResults: (publicClient: PublicClient, calls: MulticallContract[]) => Promise<{
    [contractAddress: string]: {
        [functionName: string]: any;
    };
}>;

/**
 * Returns the network name that maps to a provided chain ID
 * @param chainId chain ID that maps to a network name
 * @returns
 */
declare const getNetworkNameByChainId: (chainId: number) => string | undefined;
/**
 * Returns a formatted network name to display in the UI based on the chain ID provided
 * @param chainId chain ID to get network name for
 * @returns
 */
declare const getNiceNetworkNameByChainId: (chainId: number) => string;
/**
 * Returns a boolean representing if a network is a testnet or not
 * @param chainId chain ID to check
 * @returns
 */
declare const isTestnet: (chainId: number) => boolean;
/**
 * Returns a boolean representing if a network is configured as part of the OP stack or not
 * @param chainId chain ID to check
 * @returns
 */
declare const isOpStack: (chainId: number) => boolean;

/**
 * Calculates the odds of a user winning any prize on any one draw for a specific vault
 * @param userShares the amount of shares the user has deposited in the vault
 * @param totalShares the total amount of shares deposited in the vault
 * @param decimals the decimals of the vault
 * @param vaultPercentageContribution the percentage of the prize pool contributed by the vault
 * @param numPrizes the number of prizes expected from a draw
 * @returns
 */
declare const calculateOdds: (userShares: bigint, totalShares: bigint, decimals: number, vaultPercentageContribution: number, numPrizes: number) => number;
/**
 * Calculates the union of many probability distributions
 *
 * P(A | B) = P(A) + P(B) - P(A & B)
 * @param vals probabilities from 0 to 1 (ex: 0.2, 1, 0.5, 0.33)
 * @returns
 */
declare const calculateUnionProbability: (vals: number[]) => number;

/**
 * Returns token prices in ETH from the CloudFlare API
 * @param chainId chain ID where the token addresses provided are from
 * @param tokenAddresses token addresses to query prices for
 * @returns
 */
declare const getTokenPrices: (chainId: number, tokenAddresses?: string[]) => Promise<{
    [address: `0x${string}`]: number;
}>;
/**
 * Returns a token's historical prices in ETH from the CloudFlare API
 * @param chainId chain ID where the token addresses provided is from
 * @param tokenAddress token address to query historical prices for
 * @returns
 */
declare const getHistoricalTokenPrices: (chainId: number, tokenAddress: string) => Promise<{
    [address: `0x${string}`]: {
        date: string;
        price: number;
    }[];
}>;

/**
 * Returns a unique prize pool ID
 * @param chainId the prize pool's chain ID
 * @param address the prize pool's address
 * @returns
 */
declare const getPrizePoolId: (chainId: number, address: string) => string;
/**
 * Returns prize pool contribution amounts for any vaults during the given draw IDs
 * @param publicClient a public Viem client for the prize pool's chain
 * @param prizePoolAddress the prize pool's address
 * @param vaultAddresses the addresses for any vaults to get contributions for
 * @param startDrawId start draw ID (inclusive)
 * @param endDrawId end draw ID (inclusive)
 * @returns
 */
declare const getPrizePoolContributionAmounts: (publicClient: PublicClient, prizePoolAddress: Address, vaultAddresses: Address[], startDrawId: number, endDrawId: number) => Promise<{
    [vaultId: string]: bigint;
}>;
/**
 * Returns prize pool contribution percentages for any vaults during the given draw IDs
 *
 * NOTE: Percentage value from 0 to 1 (eg: 0.25 representing 25%)
 * @param publicClient a public Viem client for the prize pool's chain
 * @param prizePoolAddress the prize pool's address
 * @param vaultAddresses the addresses for any vaults to get contributions for
 * @param startDrawId start draw ID (inclusive)
 * @param endDrawId end draw ID (inclusive)
 * @returns
 */
declare const getPrizePoolContributionPercentages: (publicClient: PublicClient, prizePoolAddress: Address, vaultAddresses: Address[], startDrawId: number, endDrawId: number) => Promise<{
    [vaultId: string]: number;
}>;
/**
 * Returns the total supply TWAB for any vaults over the last N draws
 * @param publicClient a public Viem client for the prize pool's chain
 * @param prizePoolAddress the prize pool's address
 * @param vaultAddresses the addresses for any vaults to get total supply TWAB for
 * @param startDrawId the draw to start at (inclusive)
 * @param endDrawId the draw to end at (inclusive)
 * @returns
 */
declare const getPrizePoolTotalSupplyTwabs: (publicClient: PublicClient, prizePoolAddress: Address, vaultAddresses: Address[], startDrawId: number, endDrawId: number) => Promise<{
    [vaultId: string]: bigint;
}>;
/**
 * Returns current and estimated prize amounts and frequency for any tiers of a prize pool
 * @param publicClient a public Viem client for the prize pool's chain
 * @param prizePoolAddress the prize pool's address
 * @param tiers the prize tiers to get info for
 * @param considerPastDraws the number of past draws to consider for amount estimates (min. 1 - default is 7)
 * @returns
 */
declare const getPrizePoolAllPrizeInfo: (publicClient: PublicClient, prizePoolAddress: Address, tiers: number[], considerPastDraws?: number) => Promise<PrizeInfo[]>;

/**
 * Returns past draws from the given network's subgraph
 *
 * NOTE: By default queries the last 50 draws, with a max of 100 prizes in each
 * @param chainId the network's chain ID
 * @param options optional parameters
 * @returns
 */
declare const getSubgraphDraws: (chainId: number, options?: {
    numDraws?: number;
    numPrizes?: number;
    offsetDraws?: number;
    offsetPrizes?: number;
    drawOrderDirection?: 'asc' | 'desc';
    prizeOrderDirection?: 'asc' | 'desc';
}) => Promise<SubgraphDraw[]>;
/**
 * Returns past draws from the given network's subgraph
 *
 * NOTE: Wraps {@link getSubgraphDraws} to fetch all results regardless of number of entries
 * @param chainId the network's chain ID
 * @param options optional parameters
 */
declare const getPaginatedSubgraphDraws: (chainId: number, options?: {
    pageSize?: {
        draws?: number;
        prizes?: number;
    };
    onlyLastDraw?: boolean;
    onlyLastPrizeClaim?: boolean;
    maxRetries?: number;
}) => Promise<SubgraphDraw[]>;
/**
 * Returns a user's prize history from the given network's subgraph
 *
 * NOTE: By default queries the last 1k prizes
 * @param chainId the network's chain ID
 * @param userAddress the user's wallet address
 * @param options optional parameters
 * @returns
 */
declare const getUserSubgraphPrizes: (chainId: number, userAddress: string, options?: {
    numPrizes?: number;
    lastPrizeId?: string;
}) => Promise<SubgraphPrize[]>;
/**
 * Returns a user's prize history from the given network's subgraph
 *
 * NOTE: Wraps {@link getUserSubgraphPrizes} to fetch all results regardless of number of entries
 * @param chainId the network's chain ID
 * @param userAddress the user's wallet address
 * @param options optional parameters
 */
declare const getPaginatedUserSubgraphPrizes: (chainId: number, userAddress: string, options?: {
    pageSize?: number;
}) => Promise<SubgraphPrize[]>;
/**
 * Returns a user's TWAB observations from the given network's subgraph
 *
 * NOTE: By default queries the last 1k observations for a max of 1k vaults
 * @param chainId the network's chain ID
 * @param userAddress the user's wallet address
 * @param options optional parameters
 * @returns
 */
declare const getUserSubgraphObservations: (chainId: number, userAddress: string, options?: {
    numVaults?: number;
    numObservations?: number;
    offsetVaults?: number;
    offsetObservations?: number;
}) => Promise<{
    [vaultAddress: `0x${string}`]: SubgraphObservation[];
}>;
/**
 * Returns a user's TWAB observations from the given network's subgraph
 *
 * NOTE: Wraps {@link getUserSubgraphObservations} to fetch all results regardless of number of entries
 * @param chainId the network's chain ID
 * @param userAddress the user's wallet address
 * @param options optional parameters
 */
declare const getPaginatedUserSubgraphObservations: (chainId: number, userAddress: string, options?: {
    pageSize?: number;
}) => Promise<{
    [vaultAddress: `0x${string}`]: SubgraphObservation[];
}>;
/**
 * Returns a prize pool's unique wallet addresses
 *
 * NOTE: By default queries 1k addresses
 * @param chainId the network's chain ID
 * @param options optional parameters
 * @returns
 */
declare const getSubgraphWalletAddresses: (chainId: number, options?: {
    activeWalletsOnly?: boolean;
    numWallets?: number;
    lastWalletAddress?: Address;
}) => Promise<Lowercase<Address>[]>;
/**
 * Returns all of a prize pool's unique wallet addresses
 *
 * NOTE: Wraps {@link getSubgraphWalletAddresses} to fetch all results regardless of number of entries
 * @param chainId the network's chain ID
 * @param options optional parameters
 */
declare const getPaginatedSubgraphWalletAddresses: (chainId: number, options?: {
    activeWalletsOnly?: boolean;
    pageSize?: number;
}) => Promise<`0x${Lowercase<string>}`[]>;

/**
 * Breaks down a number of seconds into years, months, days, hours, minutes, seconds
 * @param totalSeconds
 * @returns
 */
declare const getTimeBreakdown: (totalSeconds: number | string) => {
    years: number;
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
};
/**
 * Converts milliseconds to seconds
 * @param milliseconds milliseconds as a number
 * @returns
 */
declare const msToS: (ms: number | bigint) => number;
/**
 * Converts seconds to milliseconds
 * @param seconds seconds as a number
 * @returns
 */
declare const sToMs: (seconds: number) => number;
/**
 * Converts days to milliseconds
 * @param days days as a number
 * @returns
 */
declare const dToMs: (days: number) => number;
/**
 * Converts milliseconds to days
 * @param days days as a number
 * @returns
 */
declare const msToD: (ms: number) => number;
/**
 * Converts days to seconds
 * @param days days as a number
 * @returns
 */
declare const dToS: (days: number) => number;
/**
 * Converts seconds to days
 * @param s seconds as a number
 * @returns
 */
declare const sToD: (s: number) => number;
/**
 * Converts seconds to minutes
 * @param s seconds as a number
 * @returns
 */
declare const sToM: (s: number) => number;
/**
 * Converts days to minutes
 * @param days days as a number
 * @returns
 */
declare const dToM: (days: number) => number;
/**
 * Finds the difference between two date objects in days, hours, minutes and seconds
 * @param dateA DateTime JS object (ie. new Date(Date.now()))
 * @param dateB DateTime JS object (ie. new Date(Date.now()))
 * @returns
 */
declare const subtractDates: (dateA: Date, dateB: Date) => {
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
};
/**
 * Return seconds since Epoch as a number
 * @returns
 */
declare const getSecondsSinceEpoch: () => number;
/**
 * Converts a daily event count into a frequency (every X days/weeks/months/years) with the most relevant unit of time
 * @param dailyCount Number count of times an event takes place in any given day
 * @param options optional settings
 * @returns
 */
declare const formatDailyCountToFrequency: (dailyCount: number, options?: {
    minTimespan?: number;
}) => {
    frequency: number;
    unit: TimeUnit;
};
/**
 * Returns prize frequency text for any given frequency
 * @param data data from `formatDailyCountToFrequency()`
 * @param format desired output format (default is 'everyXdays')
 * @param intl optional localization
 * @returns
 */
declare const getPrizeTextFromFrequency: (data: {
    frequency: number;
    unit: TimeUnit;
}, format: 'everyXdays' | 'daily', intl?: Intl$1<'daily' | 'weekly' | 'monthly' | 'yearly' | 'everyXdays' | 'everyXweeks' | 'everyXmonths' | 'everyXyears' | 'xPrizesDaily' | 'xPrizesWeekly' | 'xPrizesMonthly' | 'xPrizesYearly'>) => string | null;
/**
 * Returns countdown text for any given timestamp
 * @param timestamp timestamp to countdown to
 * @param intl optional localization
 * @returns
 */
declare const getCountdownTextFromTimestamp: (timestamp: number, intl?: Intl$1<'lessThanAnHour' | 'inXhours' | 'inXdays' | 'inXweeks' | 'inXmonths'>) => string | null;
/**
 * Returns a simple date showing month and day in UTC
 * @param timestamp timestamp in seconds
 */
declare const getSimpleDate: (timestamp: number) => string;
/**
 * Returns a simple time showing hours and minutes in the current locale
 * @param timestamp timestamp in seconds
 * @returns
 */
declare const getSimpleTime: (timestamp: number) => string;

/**
 * Returns basic ERC20 token info such as symbol, name, decimals and totalSupply
 * @param publicClient a public Viem client to query through
 * @param tokenAddresses token addresses to query info for
 * @returns
 */
declare const getTokenInfo: (publicClient: PublicClient, tokenAddresses: Address[]) => Promise<{
    [tokenAddress: `0x${string}`]: TokenWithSupply;
}>;
/**
 * Returns an address's token allowance to a specific contract for the provided token addresses
 * @param publicClient a public Viem client to query through
 * @param address address to check allowances for
 * @param spenderAddress the contract address that can potentially spend the allowed tokens
 * @param tokenAddresses token addresses to query allowances for
 * @returns
 */
declare const getTokenAllowances: (publicClient: PublicClient, address: Address, spenderAddress: Address, tokenAddresses: Address[]) => Promise<{
    [tokenAddress: `0x${string}`]: bigint;
}>;
/**
 * Returns an address's token balances for the provided token addresses
 * @param publicClient a public Viem client to query through
 * @param address address to check for balances in
 * @param tokenAddresses token addresses to query balances for
 * @returns
 */
declare const getTokenBalances: (publicClient: PublicClient, address: Address, tokenAddresses: Address[]) => Promise<{
    [tokenAddress: `0x${string}`]: TokenWithAmount;
}>;
/**
 * Returns an address's nonces for the provided token address
 *
 * NOTE: Returns -1n if the token does not support the EIP-2612 interface
 * @param publicClient a public Viem client to query through
 * @param address address to check nonces for
 * @param tokenAddress token address to check nonces for
 */
declare const getTokenNonces: (publicClient: PublicClient, address: Address, tokenAddress: Address) => Promise<bigint>;
/**
 * Returns a token's EIP-712 domain
 * @param publicClient a public Viem client to query through
 * @param tokenAddress token address to get domain for
 * @returns
 */
declare const getTokenDomain: (publicClient: PublicClient, tokenAddress: Address) => Promise<TypedDataDomain>;
/**
 * Returns the type of permit a token supports
 * @param publicClient a public Viem client to query through
 * @param tokenAddress token address to check permit support for
 * @param options optional settings
 */
declare const getTokenPermitSupport: (publicClient: PublicClient, tokenAddress: Address, options?: {
    domain?: TypedDataDomain;
}) => Promise<'eip2612' | 'daiPermit' | 'none'>;

/**
 * Returns promotion info for the given promotion IDs
 * @param publicClient a public Viem client to query through
 * @param promotionIds the promotion IDs to query info for
 * @param options optional settings
 * @returns
 */
declare const getPromotions: (publicClient: PublicClient, promotionIds: bigint[], options?: {
    twabRewardsAddress?: Address;
}) => Promise<{
    [id: string]: PromotionInfo | undefined;
}>;
/**
 * Returns pool-wide promotion info for the given promotion IDs
 * @param publicClient a public Viem client to query through
 * @param promotionIds the promotion IDs to query info for
 * @returns
 */
declare const getPoolWidePromotions: (publicClient: PublicClient, promotionIds: bigint[]) => Promise<{
    [id: string]: PoolWidePromotionInfo | undefined;
}>;
/**
 * Returns tokens distributed per epoch for a given vault through any pool-wide promotions
 * @param publicClient a public Viem client to query through
 * @param vaultAddress the vault to query distributions for
 * @param promotions info for the promotions to consider
 * @returns
 */
declare const getPoolWidePromotionVaultTokensPerEpoch: (publicClient: PublicClient, vaultAddress: Address, promotions: {
    [id: string]: {
        startTimestamp?: bigint | undefined;
        numberOfEpochs?: number | undefined;
        epochDuration?: number | undefined;
        tokensPerEpoch?: bigint | undefined;
    } | undefined;
}) => Promise<{
    [id: string]: bigint[];
}>;
/**
 * Returns a user's claimable rewards for the given promotions
 * @param publicClient a public Viem client to query through
 * @param userAddress the address to query rewards for
 * @param promotions info for the promotions to consider
 * @param options optional settings
 * @returns
 */
declare const getClaimableRewards: (publicClient: PublicClient, userAddress: Address, promotions: {
    [id: string]: {
        startTimestamp?: bigint | undefined;
        numberOfEpochs?: number | undefined;
        epochDuration?: number | undefined;
    };
}, options?: {
    twabRewardsAddress?: Address;
}) => Promise<{
    [id: string]: {
        [epochId: number]: bigint;
    };
}>;
/**
 * Returns a user's claimable rewards for the given pool-wide promotions
 * @param publicClient a public Viem client to query through
 * @param userAddress the address to query rewards for
 * @param vaultAddresses the prize vault addresses to consider
 * @param promotions info for the promotions to consider
 * @returns
 */
declare const getPoolWideClaimableRewards: (publicClient: PublicClient, userAddress: Address, vaultAddresses: Address[], promotions: {
    [id: string]: {
        startTimestamp?: bigint | undefined;
        numberOfEpochs?: number | undefined;
        epochDuration?: number | undefined;
    };
}) => Promise<{
    promotionId: number;
    vaultAddress: Address;
    epochRewards: {
        [epochId: number]: bigint;
    };
}[]>;
/**
 * Returns valid epochs for a given promotion
 * @param info promotion info
 * @returns
 */
declare const getPromotionEpochs: (info: {
    startTimestamp?: bigint;
    numberOfEpochs?: number;
    epochDuration?: number;
}) => number[];
/**
 * Returns an APR estimate for a given promotion for a vault
 * @param promotion the promotion to consider
 * @param rewardToken the promotion's reward token
 * @param tvl the current tvl of the vault
 * @param options optional settings
 * @returns
 */
declare const calculateRewardsApr: (promotion: PartialPromotionInfo, rewardToken: TokenWithPrice, tvl: number, options?: {
    currentTimestamp?: number;
}) => number;
/**
 * Returns an APR estimate for a given pool-wide promotion for a vault
 * @param promotion the promotion to consider
 * @param rewardToken the promotion's reward token
 * @param tvl the current tvl of the vault
 * @param options optional settings
 * @returns
 */
declare const calculatePoolWideRewardsApr: (promotion: PartialPoolWidePromotionInfo, rewardToken: TokenWithPrice, tvl: number, options?: {
    currentTimestamp?: number;
}) => number;
/**
 * Decodes claim flags from `RewardsClaimed` events into epoch IDs
 * @param claimFlags claim flags from a pool-wide TWAB rewards contract
 * @returns
 */
declare const decodePoolWideRewardsClaimFlags: (claimFlags: `0x${string}`) => number[];

/**
 * Throws an error if the address is invalid
 * @param address the address to validate
 * @param source where this function is being called from (ex. "Vault [getTokenData]")
 */
declare const validateAddress: (address: string, source?: string) => void;
/**
 * Throws an error if the WalletClient or PublicClient is invalid or for the wrong network
 * @param chainId the chain ID expected
 * @param client the WalletClient or PublicClient to validate
 * @param source where this function is being called from (ex. "Vault [getTokenData]")
 */
declare const validateClientNetwork: (chainId: number, client: WalletClient | PublicClient, source?: string) => Promise<void>;

/**
 * Returns a vault list object from an HTTP URL, IPFS/IPNS hash or ENS domain
 *
 * NOTE: If a public client is not provided, a default public RPC will be used for ENS content queries
 * @param src the source of the vault list
 * @param publicClient a public client to query ENS content through
 * @returns
 */
declare const getVaultList: (src: string, publicClient?: PublicClient) => Promise<VaultList | undefined>;
/**
 * Returns true if the given vault list object is valid
 * @param vaultList a vault list to check for validity
 * @returns
 */
declare const isValidVaultList: (vaultList?: VaultList) => boolean;
/**
 * Returns true if version `A` is newer (more recent, higher value) than version `B`
 * @param a version A
 * @param b version B
 * @returns
 */
declare const isNewerVersion: (a: Version, b: Version) => boolean;
/**
 * Returns a formatted vault list with given share and token data
 * @param data as much data as possible to format a vault list
 * @returns
 */
declare const getFormattedVaultList: (data: {
    name: string;
    version?: Version | undefined;
    timestamp?: string | undefined;
    tokens: VaultInfo[];
    keywords?: string[] | undefined;
    tags?: VaultListTags | undefined;
    logoURI?: string | undefined;
    shareData?: {
        [vaultId: string]: Token;
    } | undefined;
    tokenData?: {
        [vaultId: string]: Token;
    } | undefined;
}) => VaultList;

/**
 * Returns a unique vault ID
 * @param vaultInfo basic vault info: chain ID and address
 * @returns
 */
declare const getVaultId: (vaultInfo: VaultInfo | {
    chainId: number;
    address: string;
}) => string;
/**
 * Returns vaults that match with a given chain ID
 * @param chainId the chain to filter vaults from
 * @param vaults vaults to filter
 * @returns
 */
declare const getVaultsByChainId: (chainId: number, vaults: VaultInfo[]) => VaultInfo[];
/**
 * Returns an address's delegate balances for the provided vault addresses
 * @param publicClient a public Viem client for the chain that should be queried
 * @param userAddress the user's address to get balances for
 * @param vaultAddresses the vault addresses to query balances in
 * @param twabController the address of the TWAB controller to query through
 * @returns
 */
declare const getVaultDelegateBalances: (publicClient: PublicClient, userAddress: Address, vaultAddresses: Address[], twabController: Address) => Promise<{
    [vaultId: string]: bigint;
}>;
/**
 * Returns an address's delegates for the provided vault addresses
 * @param publicClient a public Viem client for the chain that should be queried
 * @param userAddress the user's address to get delegates for
 * @param vaultAddresses the vault addresses to check delegates for
 * @param twabController the address of the TWAB controller to query through
 * @returns
 */
declare const getVaultDelegates: (publicClient: PublicClient, userAddress: Address, vaultAddresses: Address[], twabController: Address) => Promise<{
    [vaultId: string]: `0x${string}`;
}>;
/**
 * Returns exchange rates to calculate shares to assets in each vault from a given chain
 * @param publicClient a public Viem client for the chain that should be queried
 * @param vaults vaults to query through
 * @returns
 */
declare const getVaultExchangeRates: (publicClient: PublicClient, vaults: VaultInfo[]) => Promise<{
    [vaultId: string]: bigint;
}>;
/**
 * Returns an asset amount based on shares and a vault exchange rate
 * @param shares the share amount to convert to assets
 * @param exchangeRate the vault's exchange rate (unformatted BigInt)
 * @param decimals the vault's number of decimals
 * @returns
 */
declare const getAssetsFromShares: (shares: bigint, exchangeRate: bigint, decimals: number) => bigint;
/**
 * Returns a share amount based on assets and a vault exchange rate
 * @param assets the asset amount to convert to shares
 * @param exchangeRate the vault's exchange rate (unformatted BigInt)
 * @param decimals the vault's number of decimals
 * @returns
 */
declare const getSharesFromAssets: (assets: bigint, exchangeRate: bigint, decimals: number) => bigint;
/**
 * Returns the total underlying token amount deposited in each vault from a given chain
 * @param publicClient a public Viem client for the chain that should be queried
 * @param vaults vaults to query through
 * @returns
 */
declare const getVaultBalances: (publicClient: PublicClient, vaults: VaultInfo[]) => Promise<{
    [vaultId: string]: bigint;
}>;
/**
 * Returns the vault addresses from all vaults given
 * @param vaults vaults' info
 * @returns
 */
declare const getVaultAddresses: (vaults: VaultInfo[]) => {
    [chainId: number]: `0x${string}`[];
};
/**
 * Returns all vault addresses from vault factories
 * @param publicClient a public Viem client to query through
 * @param options optional custom vault factory addresses
 * @returns
 */
declare const getVaultAddressesFromFactories: (publicClient: PublicClient, options?: {
    factoryAddresses?: Address[];
}) => Promise<`0x${Lowercase<string>}`[]>;
/**
 * Returns the underlying token addresses for each vault from a given chain
 * @param publicClient a public Viem client for the chain that should be queried
 * @param vaults vaults' info
 * @returns
 */
declare const getVaultUnderlyingTokenAddresses: (publicClient: PublicClient, vaults: VaultInfo[]) => Promise<{
    [vaultId: string]: `0x${string}`;
}>;
/**
 * Returns each vault's total delegate supply (total supply - sponsored supply)
 * @param publicClient a public Viem client for the chain that should be queried
 * @param vaults vaults to query through
 * @param twabController the address of the TWAB controller to query through
 * @returns
 */
declare const getVaultTotalDelegateSupplies: (publicClient: PublicClient, vaults: VaultInfo[], twabController: Address) => Promise<{
    [vaultId: string]: bigint;
}>;

declare const parseQueryParam: (key: string, options?: {
    default?: string;
    validValues?: string[];
}) => string | null;
declare const replaceQueryParam: (key: string, value: string) => void;
declare const pushQueryParam: (key: string, value: string) => void;
declare const deleteQueryParam: (key: string) => void;

/**
 * Returns the expected amount out for a zap into a prize vault with an underlying LP token
 * @param inputToken the zap's input token
 * @param lpVaultToken the LP token being zapped into
 * @param firstLpSwap swap data for the first token in the LP
 * @param secondLpSwap swap data for the second token in the LP
 * @returns
 */
declare const getLpSwapAmountOut: (inputToken: {
    address: Address;
    decimals: number;
    amount: bigint;
}, lpVaultToken: TokenWithSupply & {
    token0: TokenWithSupply & TokenWithAmount;
    token1: TokenWithSupply & TokenWithAmount;
}, firstLpSwap: {
    tx?: {
        tx: {
            target: Address;
            value: bigint;
            data: `0x${string}`;
        };
        amountOut: {
            expected: bigint;
            min: bigint;
        };
        allowanceProxy: Address;
    };
    isNecessary: boolean;
}, secondLpSwap: {
    tx?: {
        tx: {
            target: Address;
            value: bigint;
            data: `0x${string}`;
        };
        amountOut: {
            expected: bigint;
            min: bigint;
        };
        allowanceProxy: Address;
    };
    isNecessary: boolean;
}) => {
    expected: bigint;
    min: bigint;
};
/**
 * Returns basic TX data for a `deposit` call on a wrapped native asset contract
 * @param chainId chain ID for the transaction to take place in
 * @param amount the amount of tokens to be wrapped
 * @returns
 */
declare const getWrapTx: (chainId: number, amount: bigint) => {
    target: `0x${Lowercase<string>}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `withdraw` call on a wrapped native asset contract
 * @param chainId chain ID for the transaction to take place in
 * @param amount the amount of tokens to be unwrapped
 * @returns
 */
declare const getUnwrapTx: (chainId: number, amount: bigint) => {
    target: `0x${Lowercase<string>}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `addLiquidity` call on a velodrome-like LP contract
 * @param routerAddress the velodrome-like router address
 * @param tokenA the first token in the LP
 * @param tokenB the second token in the LP
 * @param to the recipient address of the resulting LP tokens
 * @param options optional settings
 * @returns
 */
declare const getVelodromeAddLiquidityTx: (routerAddress: Address, tokenA: {
    address: Address;
    amount: {
        expected: bigint;
        min: bigint;
    };
}, tokenB: {
    address: Address;
    amount: {
        expected: bigint;
        min: bigint;
    };
}, to: Address, options?: {
    stable?: boolean;
    deadline?: bigint;
}) => {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `add_liquidity` call on a curve LP contract
 * @param lpTokenAddress the curve LP address
 * @param underlyingTokenAmounts the amounts of each token to deposit into the LP
 * @param minOutput the transaction's minimum output
 * @returns
 */
declare const getCurveAddLiquidityTx: (lpTokenAddress: Address, underlyingTokenAmounts: [bigint, bigint], minOutput: bigint) => {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `withdraw` call to a Beefy vault contract
 * @param mooTokenAddress the Beefy vault contract to withdraw from
 * @param amount the amount to withdraw
 * @returns
 */
declare const getBeefyWithdrawTx: (mooTokenAddress: Address, amount: bigint) => {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `deposit` call to a prize vault
 * @param vaultAddress the prize vault address to deposit into
 * @param reciever the address to receive the resulting shares
 * @returns
 */
declare const getDepositTx: (vaultAddress: Address, receiver: Address) => {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
};
/**
 * Returns basic TX data for a `redeem` call to a prize vault
 * @param vaultAddress the prize vault address to redeem from
 * @param owner the address holding the shares being redeemed
 * @param amount the amount of shares to redeem
 * @param minAssets the minimum amount of assets to receive
 * @param options optional settings
 * @returns
 */
declare const getRedeemTx: (vaultAddress: Address, owner: Address, amount: bigint, minAssets: bigint, options?: {
    receiver?: Address;
}) => {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
};

export { ABIIdentifier, BLOCK_EXPLORERS, COINGECKO_API_URL, COINGECKO_NATIVE_TOKEN_IDS, COINGECKO_PLATFORM, COINGECKO_PLATFORMS, CoingeckoExchangeRates, CoingeckoTokenData, CoingeckoTokenMarketData, CoingeckoTokenPrices, Contract, ContractIdentifier, ContractList, DEAD_ADDRESS, DEFAULT_CLAIMER_ADDRESSES, DOLPHIN_ADDRESS, DOMAINS, DeepPartial, DrawStatus, DrawWithTimestamps, EIP2612SignatureTuple, EIP2612_PERMIT_TYPES, ERC2612PermitMessage, FrameButton, FrameData, FrameRequest, GasCostEstimates, Intl$1 as Intl, LINKS, LIQUIDATION_PAIR_FACTORY_ADDRESSES, LIQUIDATION_ROUTER_ADDRESSES, MAX_UINT_256, MAX_UINT_96, MINUTES_PER_DAY, MINUTES_PER_HOUR, Mutable, MutableVaultExtensions, MutableVaultInfo, MutableVaultList, NATIVE_ASSETS, NETWORK, NETWORK_NAME, OLD_DAI_PERMIT_TYPES, OP_GAS_ORACLE_ADDRESS, POOL_TOKEN_ADDRESSES, POOL_WIDE_TWAB_REWARDS_ADDRESSES, PRIZE_POOLS, PairCreateInfo, PartialPoolWidePromotionInfo, PartialPromotionInfo, PoolWidePromotionInfo, Prize, PrizeInfo, PrizePool, PromotionInfo, RichIntl, SECONDS_PER_DAY, SECONDS_PER_HOUR, SECONDS_PER_MINUTE, SECONDS_PER_MONTH, SECONDS_PER_WEEK, SECONDS_PER_YEAR, STABLECOINS, SUBGRAPH_API_URLS, SubgraphDraw, SubgraphObservation, SubgraphPrize, TOKEN_DATA_REDIRECTS, TOKEN_PRICES_API_URL, TOKEN_PRICE_API_SUPPORTED_NETWORKS, TOKEN_PRICE_REDIRECTS, TWAB_REWARDS_ADDRESSES, Tags, TimeUnit, Token, TokenWithAmount, TokenWithLogo, TokenWithPrice, TokenWithSupply, TxOverrides, USDC_TOKEN_ADDRESSES, VAULT_FACTORY_ADDRESSES, VELODROME_ADDRESSES, Vault, VaultDeployInfo, VaultExtensionValue, VaultExtensions, VaultInfo, VaultList, VaultListTags, Vaults, Version, WRAPPED_NATIVE_ASSETS, Win, ZAP_SETTINGS, abs, calculateCurrencyValue, calculateOdds, calculatePercentageOfBigInt, calculatePoolWideRewardsApr, calculateRewardsApr, calculateUnionProbability, claimerABI, curveLpTokenABI, dToM, dToMs, dToS, decodePoolWideRewardsClaimFlags, deleteQueryParam, divideBigInts, drawManagerABI, erc20ABI, erc20OldPermitABI, formatBigIntForDisplay, formatCurrencyNumberForDisplay, formatCurrencyValue, formatDailyCountToFrequency, formatNumberForDisplay, formatStringWithPrecision, getAssetsFromShares, getBeefyWithdrawTx, getBlockAtTimestamp, getBlockExplorerName, getBlockExplorerUrl, getClaimableRewards, getCoingeckoExchangeRates, getCoingeckoSimpleTokenPrices, getCoingeckoTokenData, getCoingeckoTokenPrices, getComplexMulticallResults, getCountdownTextFromTimestamp, getCurveAddLiquidityTx, getDepositEvents, getDepositTx, getDiscordInvite, getDrawAwardedEvents, getDrawFinishedEvents, getDrawStartedEvents, getFormattedVaultList, getGasFeeEstimate, getHistoricalTokenPrices, getLiquidationEvents, getLiquidationPairAddresses, getLpSwapAmountOut, getManualContributionEvents, getMaxPrecision, getMulticallResults, getNetworkNameByChainId, getNiceNetworkNameByChainId, getPaginatedSubgraphDraws, getPaginatedSubgraphWalletAddresses, getPaginatedUserSubgraphObservations, getPaginatedUserSubgraphPrizes, getPoolWideClaimableRewards, getPoolWidePromotionCreatedEvents, getPoolWidePromotionRewardsClaimedEvents, getPoolWidePromotionVaultTokensPerEpoch, getPoolWidePromotions, getPrizeBackstopEvents, getPrizePoolAllPrizeInfo, getPrizePoolContributionAmounts, getPrizePoolContributionPercentages, getPrizePoolId, getPrizePoolTotalSupplyTwabs, getPrizeTextFromFrequency, getPromotionCreatedEvents, getPromotionEpochs, getPromotionRewardsClaimedEvents, getPromotions, getRedeemTx, getSecondsSinceEpoch, getSharesFromAssets, getSimpleDate, getSimpleMulticallResults, getSimpleTime, getSubgraphDraws, getSubgraphWalletAddresses, getTimeBreakdown, getTokenAllowances, getTokenBalances, getTokenDomain, getTokenInfo, getTokenNonces, getTokenPermitSupport, getTokenPriceFromObject, getTokenPrices, getTokenTransferEvents, getUnwrapTx, getUserSubgraphObservations, getUserSubgraphPrizes, getVaultAddresses, getVaultAddressesFromFactories, getVaultBalances, getVaultContributionEvents, getVaultDelegateBalances, getVaultDelegates, getVaultExchangeRates, getVaultId, getVaultList, getVaultTotalDelegateSupplies, getVaultUnderlyingTokenAddresses, getVaultsByChainId, getVelodromeAddLiquidityTx, getWithdrawEvents, getWrapTx, isNewerVersion, isOpStack, isTestnet, isValidVaultList, liquidationPairABI, liquidationPairFactoryABI, liquidationRouterABI, lower, lpTokenABI, msToD, msToS, opGasOracleABI, parseQueryParam, poolWideTwabRewardsABI, prizePoolABI, pushQueryParam, replaceQueryParam, sToD, sToM, sToMs, shorten, sortByBigIntAsc, sortByBigIntDesc, subtractDates, twabControllerABI, twabRewardsABI, validateAddress, validateClientNetwork, vaultABI, vaultFactoryABI, zapRouterABI, zapTokenManagerABI };