import * as viem from 'viem';
import { Address, PublicClient, WalletClient, Hash, TransactionReceipt } from 'viem';
import { Chain } from 'viem/chains';
import { z } from 'zod';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';
import * as _tanstack_react_query from '@tanstack/react-query';
import { QueryClient, UseQueryResult, UseMutationResult } from '@tanstack/react-query';

declare const SUPPORTED_CHAINS: {
    readonly 96: {
        readonly id: 96;
        readonly name: "Bitkub";
        readonly nativeCurrency: {
            readonly decimals: 18;
            readonly name: "KUB";
            readonly symbol: "KUB";
        };
        readonly rpcUrls: {
            readonly default: {
                readonly http: readonly ["https://rpc.bitkubchain.io"];
            };
            readonly public: {
                readonly http: readonly ["https://rpc.bitkubchain.io"];
            };
        };
        readonly blockExplorers: {
            readonly default: {
                readonly name: "Bkcscan";
                readonly url: "https://bkcscan.com";
            };
        };
        readonly testnet: false;
    };
    readonly 25925: {
        readonly id: 25925;
        readonly name: "Bitkub Testnet";
        readonly nativeCurrency: {
            readonly decimals: 18;
            readonly name: "KUB";
            readonly symbol: "KUB";
        };
        readonly rpcUrls: {
            readonly default: {
                readonly http: readonly ["https://rpc-testnet.bitkubchain.io"];
            };
            readonly public: {
                readonly http: readonly ["https://rpc-testnet.bitkubchain.io"];
            };
        };
        readonly blockExplorers: {
            readonly default: {
                readonly name: "Bkcscan Testnet";
                readonly url: "https://testnet.bkcscan.com";
            };
        };
        readonly testnet: true;
    };
    readonly 1: {
        blockExplorers: {
            readonly default: {
                readonly name: "Etherscan";
                readonly url: "https://etherscan.io";
                readonly apiUrl: "https://api.etherscan.io/api";
            };
        };
        contracts: {
            readonly ensRegistry: {
                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
            };
            readonly ensUniversalResolver: {
                readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
                readonly blockCreated: 19258213;
            };
            readonly multicall3: {
                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
                readonly blockCreated: 14353601;
            };
        };
        id: 1;
        name: "Ethereum";
        nativeCurrency: {
            readonly name: "Ether";
            readonly symbol: "ETH";
            readonly decimals: 18;
        };
        rpcUrls: {
            readonly default: {
                readonly http: readonly ["https://cloudflare-eth.com"];
            };
        };
        sourceId?: number | undefined;
        testnet?: boolean | undefined;
        custom?: Record<string, unknown> | undefined;
        fees?: viem.ChainFees<undefined> | undefined;
        formatters?: undefined;
        serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    };
};
type SupportedChainId = keyof typeof SUPPORTED_CHAINS;
declare function getChainFromId(chainId: SupportedChainId): {
    readonly id: 96;
    readonly name: "Bitkub";
    readonly nativeCurrency: {
        readonly decimals: 18;
        readonly name: "KUB";
        readonly symbol: "KUB";
    };
    readonly rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.bitkubchain.io"];
        };
        readonly public: {
            readonly http: readonly ["https://rpc.bitkubchain.io"];
        };
    };
    readonly blockExplorers: {
        readonly default: {
            readonly name: "Bkcscan";
            readonly url: "https://bkcscan.com";
        };
    };
    readonly testnet: false;
} | {
    readonly id: 25925;
    readonly name: "Bitkub Testnet";
    readonly nativeCurrency: {
        readonly decimals: 18;
        readonly name: "KUB";
        readonly symbol: "KUB";
    };
    readonly rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc-testnet.bitkubchain.io"];
        };
        readonly public: {
            readonly http: readonly ["https://rpc-testnet.bitkubchain.io"];
        };
    };
    readonly blockExplorers: {
        readonly default: {
            readonly name: "Bkcscan Testnet";
            readonly url: "https://testnet.bkcscan.com";
        };
    };
    readonly testnet: true;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://etherscan.io";
            readonly apiUrl: "https://api.etherscan.io/api";
        };
    };
    contracts: {
        readonly ensRegistry: {
            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
        };
        readonly ensUniversalResolver: {
            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
            readonly blockCreated: 19258213;
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 14353601;
        };
    };
    id: 1;
    name: "Ethereum";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://cloudflare-eth.com"];
        };
    };
    sourceId?: number | undefined;
    testnet?: boolean | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
};

type CreatePairArgs = {
    tokenA: Address;
    tokenB: Address;
};
type CreatePairResult = {
    hash: Hash;
    wait: () => Promise<{
        pairAddress: Address;
        token0: Address;
        token1: Address;
    }>;
};
declare class Factory {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    getPair(tokenA: Address, tokenB: Address): Promise<Address>;
    allPairs(index: number): Promise<Address>;
    allPairsLength(): Promise<bigint>;
    feeTo(): Promise<Address>;
    feeToSetter(): Promise<Address>;
    createPair({ tokenA, tokenB }: CreatePairArgs): Promise<CreatePairResult>;
    setFeeTo(newFeeTo: Address): Promise<Hash>;
    setFeeToSetter(newFeeToSetter: Address): Promise<Hash>;
    setMigrator(newMigrator: Address): Promise<Hash>;
    /**
     * Get all pairs created by the factory
     * @returns Array of pair addresses
     */
    getAllPairs(): Promise<Address[]>;
}
type PonderFactory = Factory;

interface Reserves {
    reserve0: bigint;
    reserve1: bigint;
    blockTimestampLast: number;
}
type SwapArgs = {
    amount0Out: bigint;
    amount1Out: bigint;
    to: Address;
    data: string;
};
type MintResult = {
    hash: Hash;
    wait: () => Promise<{
        liquidity: bigint;
    }>;
};
type BurnResult = {
    hash: Hash;
    wait: () => Promise<{
        amount0: bigint;
        amount1: bigint;
    }>;
};
declare class Pair {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, pairAddress: Address, publicClient: PublicClient, walletClient?: WalletClient);
    MINIMUM_LIQUIDITY(): Promise<bigint>;
    factory(): Promise<Address>;
    token0(): Promise<Address>;
    token1(): Promise<Address>;
    getReserves(): Promise<Reserves>;
    price0CumulativeLast(): Promise<bigint>;
    price1CumulativeLast(): Promise<bigint>;
    kLast(): Promise<bigint>;
    launcher(): Promise<Address>;
    name(): Promise<string>;
    symbol(): Promise<string>;
    decimals(): Promise<number>;
    totalSupply(): Promise<bigint>;
    balanceOf(account: Address): Promise<bigint>;
    allowance(owner: Address, spender: Address): Promise<bigint>;
    mint(to: Address): Promise<MintResult>;
    burn(to: Address): Promise<BurnResult>;
    swap({ amount0Out, amount1Out, to, data }: SwapArgs): Promise<Hash>;
    sync(): Promise<Hash>;
    skim(to: Address): Promise<Hash>;
    approve(spender: Address, value: bigint): Promise<Hash>;
    transfer(to: Address, value: bigint): Promise<Hash>;
    transferFrom(from: Address, to: Address, value: bigint): Promise<Hash>;
}
type PonderPair = Pair;

type AddLiquidityParams$2 = {
    tokenA: Address;
    tokenB: Address;
    amountADesired: bigint;
    amountBDesired: bigint;
    amountAMin: bigint;
    amountBMin: bigint;
    to: Address;
    deadline: bigint;
};
type AddLiquidityETHParams = {
    token: Address;
    amountTokenDesired: bigint;
    amountTokenMin: bigint;
    amountETHMin: bigint;
    to: Address;
    deadline: bigint;
};
type RemoveLiquidityParams$2 = {
    tokenA: Address;
    tokenB: Address;
    liquidity: bigint;
    amountAMin: bigint;
    amountBMin: bigint;
    to: Address;
    deadline: bigint;
};
type RemoveLiquidityETHParams = {
    token: Address;
    liquidity: bigint;
    amountTokenMin: bigint;
    amountETHMin: bigint;
    to: Address;
    deadline: bigint;
};
type SwapExactTokensForTokensParams$1 = {
    amountIn: bigint;
    amountOutMin: bigint;
    path: Address[];
    to: Address;
    deadline: bigint;
};
type SwapTokensForExactTokensParams$1 = {
    amountOut: bigint;
    amountInMax: bigint;
    path: Address[];
    to: Address;
    deadline: bigint;
};
declare class Router {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    factory(): Promise<Address>;
    KKUB(): Promise<Address>;
    getAmountOut(amountIn: bigint, path: readonly `0x${string}`[]): Promise<readonly bigint[]>;
    getAmountIn(amountOut: bigint, path: readonly `0x${string}`[]): Promise<readonly bigint[]>;
    getAmountsOut(amountIn: bigint, path: Address[]): Promise<readonly bigint[]>;
    getAmountsIn(amountOut: bigint, path: Address[]): Promise<readonly bigint[]>;
    addLiquidity(params: AddLiquidityParams$2): Promise<Hash>;
    addLiquidityETH(params: AddLiquidityETHParams, value: bigint): Promise<Hash>;
    removeLiquidity(params: RemoveLiquidityParams$2): Promise<Hash>;
    removeLiquidityETH(params: RemoveLiquidityETHParams): Promise<Hash>;
    swapExactTokensForTokens(params: SwapExactTokensForTokensParams$1): Promise<Hash>;
    swapTokensForExactTokens(params: SwapTokensForExactTokensParams$1): Promise<Hash>;
}
type PonderRouter = Router;

interface PoolInfo$1 {
    lpToken: Address;
    allocPoint: bigint;
    lastRewardTime: bigint;
    accPonderPerShare: bigint;
    totalStaked: bigint;
    totalWeightedShares: bigint;
    depositFeeBP: number;
    boostMultiplier: number;
}
interface UserInfo {
    amount: bigint;
    rewardDebt: bigint;
    ponderStaked: bigint;
}
interface AddPoolParams {
    allocPoint: bigint;
    lpToken: Address;
    depositFeeBP: number;
    boostMultiplier: number;
    withUpdate: boolean;
}
declare class MasterChef {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    ponder(): Promise<Address>;
    factory(): Promise<Address>;
    ponderPerSecond(): Promise<bigint>;
    poolLength(): Promise<bigint>;
    poolInfo(pid: bigint): Promise<PoolInfo$1>;
    userInfo(pid: bigint, user: Address): Promise<UserInfo>;
    pendingPonder(pid: bigint, user: Address): Promise<bigint>;
    totalAllocPoint(): Promise<bigint>;
    startTime(): Promise<bigint>;
    owner(): Promise<Address>;
    add(params: AddPoolParams): Promise<Hash>;
    set(pid: bigint, allocPoint: bigint, withUpdate: boolean): Promise<Hash>;
    deposit(pid: bigint, amount: bigint): Promise<Hash>;
    withdraw(pid: bigint, amount: bigint): Promise<Hash>;
    emergencyWithdraw(pid: bigint): Promise<Hash>;
    boostStake(pid: bigint, amount: bigint): Promise<Hash>;
    boostUnstake(pid: bigint, amount: bigint): Promise<Hash>;
    getAllPools(): Promise<PoolInfo$1[]>;
    getUserInfoForPools(user: Address, pids: bigint[]): Promise<UserInfo[]>;
}
type PonderMasterChef = MasterChef;

interface VestingInfo {
    total: bigint;
    claimed: bigint;
    available: bigint;
    start: bigint;
    end: bigint;
}
declare class LaunchToken {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, tokenAddress: Address, publicClient: PublicClient, walletClient?: WalletClient);
    name(): Promise<string>;
    symbol(): Promise<string>;
    decimals(): Promise<number>;
    totalSupply(): Promise<bigint>;
    balanceOf(account: Address): Promise<bigint>;
    allowance(owner: Address, spender: Address): Promise<bigint>;
    launcher(): Promise<Address>;
    factory(): Promise<Address>;
    router(): Promise<Address>;
    creator(): Promise<Address>;
    vestingStart(): Promise<bigint>;
    vestingEnd(): Promise<bigint>;
    totalVestedAmount(): Promise<bigint>;
    vestedClaimed(): Promise<bigint>;
    TOTAL_SUPPLY(): Promise<bigint>;
    getVestingInfo(): Promise<VestingInfo>;
    approve(spender: Address, value: bigint): Promise<Hash>;
    transfer(to: Address, value: bigint): Promise<Hash>;
    transferFrom(from: Address, to: Address, value: bigint): Promise<Hash>;
    setupVesting(creator: Address, amount: bigint): Promise<Hash>;
    enableTransfers(): Promise<Hash>;
    claimVestedTokens(): Promise<Hash>;
}
type PonderLaunchToken = LaunchToken;

declare class Pondertoken {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    readonly MAXIMUM_SUPPLY: bigint;
    readonly MINTING_END: bigint;
    readonly TEAM_ALLOCATION: bigint;
    readonly VESTING_DURATION: bigint;
    constructor(chainId: SupportedChainId, tokenAddress: Address, publicClient: PublicClient, walletClient?: WalletClient);
    name(): Promise<string>;
    symbol(): Promise<string>;
    decimals(): Promise<number>;
    totalSupply(): Promise<bigint>;
    balanceOf(account: Address): Promise<bigint>;
    allowance(owner: Address, spender: Address): Promise<bigint>;
    launcher(): Promise<Address>;
    totalBurned(): Promise<bigint>;
    minter(): Promise<Address>;
    deploymentTime(): Promise<bigint>;
    owner(): Promise<Address>;
    pendingOwner(): Promise<Address>;
    teamTokensClaimed(): Promise<bigint>;
    approve(spender: Address, amount: bigint): Promise<Hash>;
    transfer(to: Address, amount: bigint): Promise<Hash>;
    transferFrom(from: Address, to: Address, amount: bigint): Promise<Hash>;
    burn(amount: bigint): Promise<Hash>;
    claimTeamTokens(): Promise<Hash>;
}
type PonderToken = Pondertoken;

interface LaunchInfo {
    tokenAddress: Address;
    name: string;
    symbol: string;
    imageURI: string;
    totalRaised: bigint;
    launched: boolean;
    creator: Address;
    lpUnlockTime: bigint;
    tokenPrice: bigint;
    tokensForSale: bigint;
    tokensSold: bigint;
    ponderRequired: bigint;
    ponderCollected: bigint;
}
interface SaleInfo {
    tokenPrice: bigint;
    tokensForSale: bigint;
    tokensSold: bigint;
    totalRaised: bigint;
    launched: boolean;
    remainingTokens: bigint;
}
interface CreateLaunchParams$1 {
    name: string;
    symbol: string;
    imageURI: string;
}
interface PonderMetrics {
    lpAllocation: bigint;
    protocolLPAllocation: bigint;
    burnAmount: bigint;
    requiredAmount: bigint;
}
interface PoolInfo {
    memeKubPair: `0x${string}`;
    memePonderPair: `0x${string}`;
    hasSecondaryPool: boolean;
}
interface ContributionInfo {
    kubCollected: bigint;
    ponderCollected: bigint;
    ponderValueCollected: bigint;
    totalValue: bigint;
}
declare class FiveFiveFiveLauncher {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    readonly TARGET_RAISE: bigint;
    readonly TOTAL_SUPPLY: bigint;
    readonly LP_ALLOCATION = 10n;
    readonly CREATOR_ALLOCATION = 10n;
    readonly CONTRIBUTOR_ALLOCATION = 80n;
    readonly LP_LOCK_PERIOD: bigint;
    readonly PONDER_LP_ALLOCATION = 50n;
    readonly PONDER_PROTOCOL_LP = 30n;
    readonly PONDER_BURN = 20n;
    readonly BASIS_POINTS = 10000n;
    readonly KUB_TO_MEME_KUB_LP = 6000n;
    readonly KUB_TO_MEME_PONDER_LP = 2000n;
    readonly KUB_TO_PONDER_KUB_LP = 2000n;
    readonly PONDER_TO_BURN = 2000n;
    readonly PONDER_TO_MEME_PONDER = 8000n;
    readonly PRICE_STALENESS_THRESHOLD = 7200n;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    factory(): Promise<Address>;
    router(): Promise<Address>;
    owner(): Promise<Address>;
    feeCollector(): Promise<Address>;
    launchCount(): Promise<bigint>;
    getLaunchInfo(launchId: bigint): Promise<LaunchInfo>;
    getPoolInfo(launchId: bigint): Promise<PoolInfo>;
    getContributionInfo(launchId: bigint): Promise<ContributionInfo>;
    getRemainingToRaise(launchId: bigint): Promise<[bigint, bigint]>;
    calculatePonderRequirements(): Promise<PonderMetrics>;
    createLaunch(params: CreateLaunchParams$1): Promise<Hash>;
    contributeKUB(launchId: bigint, amount: bigint): Promise<Hash>;
    contributePONDER(launchId: bigint, amount: bigint): Promise<Hash>;
    withdrawLP(launchId: bigint): Promise<Hash>;
}
type PonderLauncher = FiveFiveFiveLauncher;

interface Observation {
    timestamp: number;
    price0Cumulative: bigint;
    price1Cumulative: bigint;
}
declare class PriceOracle {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    readonly PERIOD = 86400n;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    factory(): Promise<Address>;
    observationLength(pair: Address): Promise<bigint>;
    observations(pair: Address, index: bigint): Promise<Observation>;
    consult(pair: Address, tokenIn: Address, amountIn: bigint, periodInSeconds: number): Promise<bigint>;
    update(pair: Address): Promise<Hash>;
    getAveragePrice(pair: Address, tokenIn: Address, amountIn: bigint, period?: number): Promise<{
        amountOut: bigint;
        pricePerToken: number;
    }>;
    getLatestObservation(pair: Address): Promise<Observation | null>;
    getPriceHistory(pair: Address, fromIndex?: bigint, toIndex?: bigint): Promise<Observation[]>;
    getPriceChange(pair: Address, tokenIn: Address, period?: number): Promise<{
        absoluteChange: number;
        percentageChange: number;
    }>;
}
type PonderPriceOracle = PriceOracle;

declare class KKUBUnwrapper {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    KKUB(): Promise<Address>;
    owner(): Promise<Address>;
    pendingOwner(): Promise<Address>;
    unwrapKKUB(amount: bigint, recipient: Address): Promise<Hash>;
    transferOwnership(newOwner: Address): Promise<Hash>;
    acceptOwnership(): Promise<Hash>;
    emergencyWithdraw(): Promise<Hash>;
    emergencyWithdrawTokens(token: Address): Promise<Hash>;
}
type PonderKKUBUnwrapper = KKUBUnwrapper;

declare class Staking {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    readonly abi: readonly [{
        readonly type: "constructor";
        readonly inputs: readonly [{
            readonly name: "_ponder";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "_router";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "_factory";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "DEPLOYMENT_TIME";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "FACTORY";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IPonderFactory";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "PERMIT_TYPEHASH";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "PONDER";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IERC20";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "PROJECT";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "string";
            readonly internalType: "string";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "ROUTER";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IPonderRouter";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "acceptOwnership";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "acceptedKYCLevel";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "accumulatedFeesPerShare";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "activateOnlyKYCAddress";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "adminApprove";
        readonly inputs: readonly [{
            readonly name: "owner_";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "adminProjectRouter";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IAdminProjectRouter";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "adminTransfer";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "allowance";
        readonly inputs: readonly [{
            readonly name: "owner_";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "approve";
        readonly inputs: readonly [{
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "balanceOf";
        readonly inputs: readonly [{
            readonly name: "account";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "claimFees";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "committee";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "decimals";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint8";
            readonly internalType: "uint8";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "domainSeparator";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "enter";
        readonly inputs: readonly [{
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "shares";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "externalTransfer";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "getAccumulatedFeesPerShare";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "getPendingFees";
        readonly inputs: readonly [{
            readonly name: "user";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "getPonderAmount";
        readonly inputs: readonly [{
            readonly name: "shares";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "getSharesAmount";
        readonly inputs: readonly [{
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "internalTransfer";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "isActivatedOnlyKYCAddress";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "kyc";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IKYCBitkubChain";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "lastRebaseTime";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "leave";
        readonly inputs: readonly [{
            readonly name: "shares";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "minimumFirstStake";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "pure";
    }, {
        readonly type: "function";
        readonly name: "name";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "string";
            readonly internalType: "string";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "nonces";
        readonly inputs: readonly [{
            readonly name: "owner_";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "owner";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "pause";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "paused";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "pendingOwner";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "permit";
        readonly inputs: readonly [{
            readonly name: "owner_";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "value";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "deadline";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "v";
            readonly type: "uint8";
            readonly internalType: "uint8";
        }, {
            readonly name: "r";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }, {
            readonly name: "s";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "ponderPerShare";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "rebase";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "setAcceptedKYCLevel";
        readonly inputs: readonly [{
            readonly name: "_kycLevel";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "setAdminProjectRouter";
        readonly inputs: readonly [{
            readonly name: "_adminProjectRouter";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "setCommittee";
        readonly inputs: readonly [{
            readonly name: "_committee";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "setKYC";
        readonly inputs: readonly [{
            readonly name: "_kyc";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "setTransferRouter";
        readonly inputs: readonly [{
            readonly name: "_transferRouter";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "stakingOwner";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "symbol";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "string";
            readonly internalType: "string";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "totalDepositedPonder";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "totalSupply";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "totalUnclaimedFees";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "transfer";
        readonly inputs: readonly [{
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "transferFrom";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "recipient";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [{
            readonly name: "success";
            readonly type: "bool";
            readonly internalType: "bool";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "transferOwnership";
        readonly inputs: readonly [{
            readonly name: "newOwner";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "transferRouter";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "unpause";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "userFeeDebt";
        readonly inputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "event";
        readonly name: "AcceptedKYCLevelSet";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "oldKYCLevel";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "newKYCLevel";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "ActivateOnlyKYCAddress";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "AdminProjectRouterSet";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "oldAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "newAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Approval";
        readonly inputs: readonly [{
            readonly name: "owner";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "spender";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "value";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "CommitteeSet";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "oldAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "newAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "FeesClaimed";
        readonly inputs: readonly [{
            readonly name: "user";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "FeesDistributed";
        readonly inputs: readonly [{
            readonly name: "amount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "accumulatedFeesPerShare";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "KYCBitkubChainSet";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "oldAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "newAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "OwnershipTransferInitiated";
        readonly inputs: readonly [{
            readonly name: "currentOwner";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "pendingOwner";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "OwnershipTransferred";
        readonly inputs: readonly [{
            readonly name: "previousOwner";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "newOwner";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Paused";
        readonly inputs: readonly [{
            readonly name: "account";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "RebasePerformed";
        readonly inputs: readonly [{
            readonly name: "totalSupply";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "totalPonderBalance";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Staked";
        readonly inputs: readonly [{
            readonly name: "user";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "ponderAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "xPonderAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Transfer";
        readonly inputs: readonly [{
            readonly name: "from";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "to";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "value";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "TransferRouterSet";
        readonly inputs: readonly [{
            readonly name: "caller";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "oldAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "newAddress";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Unpaused";
        readonly inputs: readonly [{
            readonly name: "account";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "Withdrawn";
        readonly inputs: readonly [{
            readonly name: "user";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "ponderAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "xPonderAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "error";
        readonly name: "AddressEmptyCode";
        readonly inputs: readonly [{
            readonly name: "target";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "AddressInsufficientBalance";
        readonly inputs: readonly [{
            readonly name: "account";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "AlreadyInitialized";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ECDSAInvalidSignature";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ECDSAInvalidSignatureLength";
        readonly inputs: readonly [{
            readonly name: "length";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
    }, {
        readonly type: "error";
        readonly name: "ECDSAInvalidSignatureS";
        readonly inputs: readonly [{
            readonly name: "s";
            readonly type: "bytes32";
            readonly internalType: "bytes32";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InsufficientAllowance";
        readonly inputs: readonly [{
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "allowance";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "needed";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InsufficientBalance";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "balance";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }, {
            readonly name: "needed";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InvalidApprover";
        readonly inputs: readonly [{
            readonly name: "approver";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InvalidReceiver";
        readonly inputs: readonly [{
            readonly name: "receiver";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InvalidSender";
        readonly inputs: readonly [{
            readonly name: "sender";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "ERC20InvalidSpender";
        readonly inputs: readonly [{
            readonly name: "spender";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "ExcessiveFeeAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ExcessiveShareRatio";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FailedInnerCall";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FeeAccountingError";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FeeDistributionFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FeePrecisionLoss";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FeeTransferFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InsufficientFeeAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InsufficientFirstStake";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidBalance";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidKYCLevel";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidShareRatio";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidSharesAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidSignature";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "KYCNotApproved";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "MinimumSharesRequired";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NoFeesToClaim";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NotAuthorized";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NotOwner";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NotPendingOwner";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "PausedToken";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "PermitExpired";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "RebaseTooFrequent";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "SafeERC20FailedOperation";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly internalType: "address";
        }];
    }, {
        readonly type: "error";
        readonly name: "TeamStakingLocked";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "TransferFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ZeroAddress";
        readonly inputs: readonly [];
    }];
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    PONDER(): Promise<Address>;
    minimumFirstStake(): Promise<bigint>;
    totalSupply(): Promise<bigint>;
    balanceOf(account: Address): Promise<bigint>;
    lastRebaseTime(): Promise<bigint>;
    owner(): Promise<Address>;
    pendingOwner(): Promise<Address>;
    getPonderAmount(shares: bigint): Promise<bigint>;
    getSharesAmount(amount: bigint): Promise<bigint>;
    getPendingFees(user: Address): Promise<bigint>;
    enter(amount: bigint, recipient: Address): Promise<Hash>;
    leave(shares: bigint): Promise<Hash>;
    rebase(): Promise<Hash>;
    claimFees(): Promise<Hash>;
    transferOwnership(newOwner: Address): Promise<Hash>;
    acceptOwnership(): Promise<Hash>;
}
type PonderStaking = Staking;

declare class FeeDistributor {
    readonly chainId: SupportedChainId;
    readonly address: Address;
    readonly chain: Chain;
    readonly abi: readonly [{
        readonly type: "constructor";
        readonly inputs: readonly [{
            readonly name: "_factory";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "_router";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "_ponder";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "_staking";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "FACTORY";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IPonderFactory";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "PONDER";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "ROUTER";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IPonderRouter";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "STAKING";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "contract IPonderStaking";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "acceptOwnership";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "collectFeesFromPair";
        readonly inputs: readonly [{
            readonly name: "pair";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "convertFees";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "distribute";
        readonly inputs: readonly [];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "distributePairFees";
        readonly inputs: readonly [{
            readonly name: "pairs";
            readonly type: "address[]";
            readonly internalType: "address[]";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "emergencyTokenRecover";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "to";
            readonly type: "address";
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "function";
        readonly name: "lastDistributionTimestamp";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "lastPairDistribution";
        readonly inputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "minimumAmount";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "uint256";
            readonly internalType: "uint256";
        }];
        readonly stateMutability: "pure";
    }, {
        readonly type: "function";
        readonly name: "owner";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "pendingOwner";
        readonly inputs: readonly [];
        readonly outputs: readonly [{
            readonly name: "";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly stateMutability: "view";
    }, {
        readonly type: "function";
        readonly name: "transferOwnership";
        readonly inputs: readonly [{
            readonly name: "newOwner";
            readonly type: "address";
            readonly internalType: "address";
        }];
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
    }, {
        readonly type: "event";
        readonly name: "EmergencyTokenRecovered";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "to";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "FeesCollected";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "amount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "FeesConverted";
        readonly inputs: readonly [{
            readonly name: "token";
            readonly type: "address";
            readonly indexed: true;
            readonly internalType: "address";
        }, {
            readonly name: "tokenAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }, {
            readonly name: "ponderAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "event";
        readonly name: "FeesDistributed";
        readonly inputs: readonly [{
            readonly name: "totalAmount";
            readonly type: "uint256";
            readonly indexed: false;
            readonly internalType: "uint256";
        }];
        readonly anonymous: false;
    }, {
        readonly type: "error";
        readonly name: "AmountTooLarge";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ApprovalFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "DistributionTooFrequent";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "FeeCollectionFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InsufficientAccumulation";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InsufficientLiquidity";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InsufficientOutputAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidCollectionState";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidFeeState";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidPair";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidPairAddress";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidPairCount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidRatio";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidRecipient";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidRecoveryAmount";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidReserveState";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "InvalidReserves";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NotOwner";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "NotPendingOwner";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "PairNotFound";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "RatioSumIncorrect";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ReentrancyGuardReentrantCall";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "SwapFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "SyncValidationFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "TransferFailed";
        readonly inputs: readonly [];
    }, {
        readonly type: "error";
        readonly name: "ZeroAddress";
        readonly inputs: readonly [];
    }];
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: SupportedChainId, publicClient: PublicClient, walletClient?: WalletClient);
    minimumAmount(): Promise<bigint>;
    lastDistributionTimestamp(): Promise<bigint>;
    owner(): Promise<Address>;
    pendingOwner(): Promise<Address>;
    distribute(): Promise<Hash>;
    distributePairFees(pairs: Address[]): Promise<Hash>;
    convertFees(token: Address): Promise<Hash>;
    collectFeesFromPair(pair: Address): Promise<Hash>;
    emergencyTokenRecover(token: Address, to: Address, amount: bigint): Promise<Hash>;
    transferOwnership(newOwner: Address): Promise<Hash>;
    acceptOwnership(): Promise<Hash>;
}
type PonderFeeDistributor = FeeDistributor;

declare const ChainIdSchema: z.ZodEffects<z.ZodEnum<["1", "42161", "10", "8453"]>, number, "1" | "10" | "42161" | "8453">;
type ChainId = z.infer<typeof ChainIdSchema>;

declare const KKUB_ADDRESS: Record<ChainId, Address>;

declare enum DEST_TOKEN_TYPE {
    INVALID_0 = 0,
    NATIVE = 1,
    ERC20 = 2,
    NATIVE_ERC20 = 3
}
declare enum FEE_TYPE {
    NO_FEE = 0,
    FIX = 1,
    PERCENTAGE = 2
}
declare enum TOKEN_STRATEGY {
    LOCK = 0,
    BURN = 1
}
type BridgeInfo = {
    enabled: boolean;
    token: Address;
    chainID: bigint;
    allowedDestTokenTypes: DEST_TOKEN_TYPE;
    feeReceiver: Address;
    fee: bigint;
    feeType: FEE_TYPE;
    strategy: TOKEN_STRATEGY;
    receiver: Address;
};
type ChainIDAndAllowedDestTokenTypes = {
    chainID: bigint;
    allowedDestTokenTypes: DEST_TOKEN_TYPE;
};
interface BridgeParams {
    token: Address;
    amount: bigint;
    destChainID: bigint;
    destTokenType: DEST_TOKEN_TYPE;
}
interface NativeBridgeParams {
    destChainID: bigint;
    destTokenType: DEST_TOKEN_TYPE;
}
declare class Bridge {
    readonly chainId: number;
    readonly address: Address;
    readonly chain: Chain;
    private readonly publicClient;
    private readonly walletClient?;
    constructor(chainId: 96 | 25925 | 1, address: Address, publicClient: PublicClient, walletClient?: WalletClient);
    getBridgeInfo(token: Address, chainId: bigint): Promise<BridgeInfo>;
    computeFee(token: Address, destChainId: bigint, amount: bigint): Promise<bigint>;
    getDestChainIDs(token: Address): Promise<ChainIDAndAllowedDestTokenTypes[]>;
    isPaused(): Promise<boolean>;
    bridgeTokens(params: BridgeParams): Promise<Hash>;
    bridgeNative(params: NativeBridgeParams, value: bigint): Promise<Hash>;
}
type PonderBridge = Bridge;

declare function PonderProvider({ sdk, children, queryClient, }: {
    sdk: PonderSDK | undefined;
    children: ReactNode;
    queryClient: QueryClient;
}): react_jsx_runtime.JSX.Element;
declare function usePonderSDK(): PonderSDK;

interface FeeInfo {
    lpFee: bigint;
    creatorFee: bigint;
    protocolFee: bigint;
    recipient: `0x${string}`;
    ponderRequired?: bigint;
    ponderBurn?: bigint;
}

interface TokenInfo {
    name: string;
    symbol: string;
    decimals: number;
    totalSupply: bigint;
}
declare function useTokenInfo(tokenAddress: Address, enabled?: boolean): UseQueryResult<TokenInfo>;

declare function useTokenBalance(tokenAddress: Address, account: Address | undefined, enabled?: boolean): UseQueryResult<bigint>;

interface ApprovalParams {
    token: Address;
    spender: Address;
    amount: bigint;
    useUnlimited?: boolean;
}
interface ApprovalResult {
    hash: Hash;
    spender: Address;
    amount: bigint;
}
declare function useTokenApproval(token: Address | undefined, spender: Address | undefined, options?: {}, enabled?: boolean): {
    allowance: UseQueryResult<bigint>;
    approve: UseMutationResult<ApprovalResult, Error, ApprovalParams>;
    isApproved: (amount: bigint) => boolean;
};

interface AllowanceData {
    amount: bigint;
    isUnlimited: boolean;
    isZero: boolean;
    hasAllowance: (required: bigint) => boolean;
}
declare function useTokenAllowance(token: Address | undefined, spender: Address | undefined, owner: Address | undefined, enabled?: boolean): UseQueryResult<AllowanceData>;

declare function usePairFees(pair: PonderPair, tokenIn: Address, enabled?: boolean): UseQueryResult<FeeInfo>;

declare function useAmountOut(pair: PonderPair, tokenIn: Address, amountIn: bigint, enabled?: boolean): UseQueryResult<bigint>;
declare function useAmountIn(pair: PonderPair, tokenOut: Address, amountOut: bigint, enabled?: boolean): UseQueryResult<bigint>;

interface TradeInfo {
    priceImpact: number;
    minimumReceived: bigint;
    fee: {
        lp: bigint;
        creator: bigint;
        total: bigint;
    };
}
declare function useTradeInfo(pair: PonderPair, tokenIn: Address, amountIn: bigint, slippageTolerance?: number, enabled?: boolean): UseQueryResult<TradeInfo>;

interface BaseSwapParams {
    path: Address[];
    to: Address;
    deadline: bigint;
}
interface SwapExactTokensForTokensParams extends BaseSwapParams {
    amountIn: bigint;
    amountOutMin: bigint;
}
interface SwapTokensForExactTokensParams extends BaseSwapParams {
    amountOut: bigint;
    amountInMax: bigint;
}
interface SwapExactETHForTokensParams extends BaseSwapParams {
    amountOutMin: bigint;
}
interface SwapTokensForExactETHParams extends BaseSwapParams {
    amountOut: bigint;
    amountInMax: bigint;
}
interface SwapExactTokensForETHParams extends BaseSwapParams {
    amountIn: bigint;
    amountOutMin: bigint;
}
interface SwapETHForExactTokensParams extends BaseSwapParams {
    amountOut: bigint;
    value: bigint;
}
type SwapParams = {
    type: "exactTokensForTokens";
    params: SwapExactTokensForTokensParams;
} | {
    type: "tokensForExactTokens";
    params: SwapTokensForExactTokensParams;
} | {
    type: "exactETHForTokens";
    params: SwapExactETHForTokensParams;
    value: bigint;
} | {
    type: "ETHForExactTokens";
    params: SwapETHForExactTokensParams;
} | {
    type: "exactTokensForETH";
    params: SwapExactTokensForETHParams;
} | {
    type: "tokensForExactETH";
    params: SwapTokensForExactETHParams;
};
interface SwapResult {
    hash: Hash;
    amounts: {
        amountIn: bigint;
        amountOut: bigint;
    };
    fees: {
        lp: bigint;
        creator?: bigint;
        recipient?: Address;
    };
    events: {
        swap?: {
            sender: Address;
            amount0In: bigint;
            amount1In: bigint;
            amount0Out: bigint;
            amount1Out: bigint;
            to: Address;
        };
        transfers: Array<{
            from: Address;
            to: Address;
            value: bigint;
        }>;
    };
}
declare function useSwap(): UseMutationResult<SwapResult, Error, SwapParams>;

interface SwapRoute {
    path: Address[];
    pairs: Address[];
    amountIn: bigint;
    amountOut: bigint;
    priceImpact: number;
    totalFee: bigint;
    hops: Array<{
        pair: Address;
        tokenIn: Address;
        tokenOut: Address;
        amountIn: bigint;
        amountOut: bigint;
        fee: bigint;
        priceImpact: number;
    }>;
}
interface SwapRouteParams {
    tokenIn: Address;
    tokenOut: Address;
    amountIn?: bigint;
    amountOut?: bigint;
    maxHops?: number;
}
declare function useSwapRoute(params: SwapRouteParams | undefined, enabled?: boolean): UseQueryResult<SwapRoute | null>;

interface SwapApprovalParams {
    tokenIn: Address;
    amountIn: bigint;
    useUnlimited?: boolean;
}
interface ApprovalState {
    state: "unknown" | "required" | "approved";
    isUnlimited: boolean;
    currentAllowance: bigint;
}
interface SwapApprovalResult {
    hash: Hash;
    state: ApprovalState;
}
declare function useSwapApproval(): UseMutationResult<SwapApprovalResult, Error, SwapApprovalParams>;

interface PairInfo {
    address: Address;
    token0: Address;
    token1: Address;
    token0Symbol: string;
    token1Symbol: string;
    token0Decimals: number;
    token1Decimals: number;
    reserve0: bigint;
    reserve1: bigint;
    totalSupply: bigint;
    kLast: bigint;
    fee: {
        LP: bigint;
        creator: bigint;
        recipient?: Address;
    };
    launch?: {
        token: Address;
        creator: Address;
        launcher: Address;
        isPair0Launch: boolean;
    };
}
declare function usePairInfo(pairAddress: Address | undefined, enabled?: boolean): UseQueryResult<PairInfo & {
    asPair: () => Pair;
}>;

interface PairExistsResult {
    exists: boolean;
    pairAddress: Address | null;
    canCreate: boolean;
    token0: Address | null;
    token1: Address | null;
}
declare function usePairExists(tokenA: Address | undefined, tokenB: Address | undefined, enabled?: boolean): UseQueryResult<PairExistsResult>;

interface PairCreationParams {
    token0: Address;
    token1: Address;
}
interface PairCreationResult {
    hash: Hash;
    pair: Address;
    events: {
        pairCreated?: {
            token0: Address;
            token1: Address;
            pair: Address;
        };
    };
}
interface PairCreationData {
    canCreate: boolean;
    error?: string;
    existingPair?: Address;
    sortedTokens: Address[];
    estimatedGas?: bigint;
}
declare function usePairCreation(tokens?: [Address, Address]): {
    data: UseQueryResult<PairCreationData>;
    createPair: UseMutationResult<PairCreationResult, Error, PairCreationParams>;
};

interface QuoteParams {
    tokenA: Address;
    tokenB: Address;
    amountADesired?: bigint;
    amountBDesired?: bigint;
}
interface PairQuote {
    amountA: bigint;
    amountB: bigint;
    share: number;
    amountAMin: bigint;
    amountBMin: bigint;
    priceImpact: number;
}
declare function usePairQuote(params: QuoteParams | undefined, slippageBps?: number, // 0.5% default slippage
enabled?: boolean): UseQueryResult<PairQuote>;

interface AddLiquidityParams$1 {
    tokenA: Address;
    tokenB: Address;
    amountADesired: bigint;
    amountBDesired: bigint;
    amountAMin: bigint;
    amountBMin: bigint;
    deadline?: bigint;
}
interface RemoveLiquidityParams$1 {
    tokenA: Address;
    tokenB: Address;
    liquidity: bigint;
    amountAMin: bigint;
    amountBMin: bigint;
    deadline?: bigint;
}
interface LiquidityResult {
    hash: Hash;
    amounts: {
        amountA: bigint;
        amountB: bigint;
        liquidity: bigint;
    };
}
interface PairLiquidity {
    tokenA: Address;
    tokenB: Address;
    balance: bigint;
    totalSupply: bigint;
    token0Amount: bigint;
    token1Amount: bigint;
    poolShare: number;
    approvals: {
        tokenA: bigint;
        tokenB: bigint;
        pair: bigint;
    };
}
declare function usePairLiquidity(pair: Address | undefined, account: Address | undefined, enabled?: boolean): {
    data: UseQueryResult<PairLiquidity>;
    addLiquidity: UseMutationResult<LiquidityResult, Error, AddLiquidityParams$1>;
    removeLiquidity: UseMutationResult<LiquidityResult, Error, RemoveLiquidityParams$1>;
};

interface AddLiquidityParams {
    tokenA: Address;
    tokenB: Address;
    amountADesired: bigint;
    amountBDesired: bigint;
    amountAMin: bigint;
    amountBMin: bigint;
    to: Address;
    deadline: bigint;
}
interface AddLiquidityResult {
    hash: Hash;
    amounts: {
        amountA: bigint;
        amountB: bigint;
        liquidity: bigint;
    };
    events: {
        transfer?: {
            from: Address;
            to: Address;
            value: bigint;
        };
        mint?: {
            sender: Address;
            amount0: bigint;
            amount1: bigint;
        };
    };
}
declare function useAddLiquidity(): UseMutationResult<AddLiquidityResult, Error, AddLiquidityParams>;

interface RemoveLiquidityParams {
    pairAddress: Address;
    liquidity: bigint;
    token0Min: bigint;
    token1Min: bigint;
    deadline?: bigint;
    toAddress?: Address;
    isETHPair?: boolean;
    tokenAddress?: Address;
    amountTokenMin?: bigint;
    amountETHMin?: bigint;
    supportsFeeOnTransfer?: boolean;
}
interface RemoveLiquidityResult {
    hash: Hash;
    amounts: {
        token0: bigint;
        token1: bigint;
    };
}
declare function useRemoveLiquidity(): UseMutationResult<RemoveLiquidityResult, unknown, RemoveLiquidityParams, unknown>;

interface PositionValue {
    token0Amount: bigint;
    token1Amount: bigint;
    token0Symbol: string;
    token1Symbol: string;
    lpBalance: bigint;
    sharePercent: number;
    token0ValueUSD?: number;
    token1ValueUSD?: number;
    totalValueUSD?: number;
    impermanentLoss?: {
        percent: number;
        valueUSD?: number;
    };
    feesEarned?: {
        token0Amount: bigint;
        token1Amount: bigint;
        valueUSD?: number;
    };
}
declare function usePositionValue(pairAddress: Address | undefined, account: Address | undefined, enabled?: boolean): UseQueryResult<PositionValue>;

interface LiquidityPosition {
    pairAddress: Address;
    balance: bigint;
    totalSupply: bigint;
    sharePercentage: number;
    token0Amount: bigint;
    token1Amount: bigint;
    token0Symbol: string;
    token1Symbol: string;
    usdValue?: bigint;
}
declare function useLPTokenBalance(pairAddress: Address | undefined, account: Address | undefined, enabled?: boolean): UseQueryResult<LiquidityPosition>;

interface PairSummary {
    address: Address;
    token0: Address;
    token1: Address;
    token0Symbol: string;
    token1Symbol: string;
    token0Decimals: number;
    token1Decimals: number;
    reserve0: bigint;
    reserve1: bigint;
    totalSupply: bigint;
}
/**
 * Hook to fetch all existing pairs from the factory
 * @param options.enabled Whether the query should execute
 * @param options.includeTotalSupply Whether to fetch total supply for each pair (slightly more gas)
 * @param options.includeReserves Whether to fetch reserves for each pair (slightly more gas)
 * @returns UseQueryResult with array of all pair information
 */
declare function useAllPairs(options?: {
    enabled?: boolean;
    includeTotalSupply?: boolean;
    includeReserves?: boolean;
}): UseQueryResult<PairSummary[]>;

interface DetailedPoolInfo extends PoolInfo$1 {
    poolId: number;
    totalStakedUSD: bigint;
    apr: number;
    rewardsPerDay: bigint;
}
declare function usePoolInfo(poolId: number, enabled?: boolean): UseQueryResult<DetailedPoolInfo>;

interface DetailedStakeInfo extends UserInfo {
    poolId: number;
    pendingRewards: bigint;
    lpToken: Address;
    boost: {
        multiplier: number;
        ponderRequired: bigint;
        additionalRewards: bigint;
    };
}
declare function useStakeInfo(poolId: number, account: Address | undefined, enabled?: boolean): UseQueryResult<DetailedStakeInfo>;

interface StakeParams$1 {
    poolId: number;
    amount: bigint;
}
interface StakeResult {
    hash: Hash;
    amount: bigint;
    events: {
        deposit?: {
            user: Address;
            pid: bigint;
            amount: bigint;
        };
    };
}
declare function useStake(): UseMutationResult<StakeResult, Error, StakeParams$1>;

interface UnstakeParams$1 {
    poolId: number;
    amount: bigint;
}
interface UnstakeResult {
    hash: Hash;
    amount: bigint;
    events: {
        withdraw?: {
            user: Address;
            pid: bigint;
            amount: bigint;
        };
    };
}
declare function useUnstake(): UseMutationResult<UnstakeResult, Error, UnstakeParams$1>;

interface HarvestParams {
    poolId: number;
}
interface HarvestResult {
    hash: Hash;
    rewards: bigint;
    events: {
        deposit?: {
            user: Address;
            pid: bigint;
            amount: bigint;
        };
        transfer?: {
            from: Address;
            to: Address;
            value: bigint;
        };
    };
}
declare function useHarvest(): UseMutationResult<HarvestResult, Error, HarvestParams>;

interface BoostStakeParams {
    poolId: number;
    amount: bigint;
}
interface BoostUnstakeParams extends BoostStakeParams {
}
interface BoostResult {
    hash: Hash;
    amount: bigint;
    events: {
        boostStake?: {
            user: Address;
            pid: bigint;
            amount: bigint;
        };
        boostUnstake?: {
            user: Address;
            pid: bigint;
            amount: bigint;
        };
    };
}
declare function useBoostStake(): UseMutationResult<BoostResult, Error, BoostStakeParams>;
declare function useBoostUnstake(): UseMutationResult<BoostResult, Error, BoostUnstakeParams>;

interface PendingRewards {
    base: bigint;
    boosted: bigint;
    total: bigint;
    usdValue: number;
}
declare function usePendingRewards(poolId: number, account: Address | undefined, enabled?: boolean): UseQueryResult<PendingRewards>;

interface FarmMetrics {
    totalValueLocked: bigint;
    rewardsPerDay: bigint;
    totalStakers: number;
    averageApr: number;
    activePools: number;
}
declare function useFarmMetrics(enabled?: boolean): UseQueryResult<FarmMetrics>;

interface DetailedLaunchInfo extends LaunchInfo {
    progress: number;
    timeRemaining?: number;
    status: "upcoming" | "active" | "completed" | "failed";
    metrics: {
        participantsCount: number;
        averageContribution: bigint;
        remainingAllocation: bigint;
    };
}
declare function useLaunchInfo(launchId: bigint, enabled?: boolean): UseQueryResult<DetailedLaunchInfo>;

interface CreateLaunchParams {
    name: string;
    symbol: string;
    imageURI: string;
}
interface CreateLaunchResult {
    hash: Hash;
    launchId: bigint;
    token: {
        address: Address;
        name: string;
        symbol: string;
    };
    ponderMetrics: {
        required: bigint;
        lpAllocation: bigint;
        protocolLPAmount: bigint;
        burnAmount: bigint;
    };
    events: {
        launchCreated?: {
            launchId: bigint;
            token: Address;
            creator: Address;
            imageURI: string;
        };
        dualPoolsCreated?: {
            launchId: bigint;
            memeKubPair: Address;
            memePonderPair: Address;
            kubLiquidity: bigint;
            ponderLiquidity: bigint;
        };
    };
}
declare function useCreateLaunch(): UseMutationResult<CreateLaunchResult, Error, CreateLaunchParams>;

type ContributeType = "KUB" | "PONDER";
interface BaseContributeParams {
    launchId: bigint;
    amount: bigint;
    type: ContributeType;
}
interface ContributeResult {
    hash: Hash;
    contribution: {
        amount: bigint;
        kubValue: bigint;
    };
    ponderMetrics?: {
        lpAllocation: bigint;
        protocolLPAllocation: bigint;
        burnAmount: bigint;
    };
    events: {
        kubContributed?: {
            launchId: bigint;
            contributor: Address;
            amount: bigint;
        };
        ponderContributed?: {
            launchId: bigint;
            contributor: Address;
            amount: bigint;
            kubValue: bigint;
        };
        dualPoolsCreated?: {
            launchId: bigint;
            memeKubPair: Address;
            memePonderPair: Address;
            kubLiquidity: bigint;
            ponderLiquidity: bigint;
        };
        ponderBurned?: {
            launchId: bigint;
            amount: bigint;
        };
    };
}
declare function useContribute(): UseMutationResult<ContributeResult, Error, BaseContributeParams>;

interface DetailedVestingInfo {
    totalVested: bigint;
    vestedAmount: bigint;
    claimedAmount: bigint;
    availableToClaim: bigint;
    vestingStart: bigint;
    vestingEnd: bigint;
    nextClaimDate?: bigint;
    percentageVested: number;
    percentageClaimed: number;
    isFullyVested: boolean;
    isFullyClaimed: boolean;
    dailyVestingRate: bigint;
    creator?: Address;
    creatorFees?: bigint;
    teamAllocation?: bigint;
    teamClaimed?: bigint;
}
interface VestingParams {
    token: Address;
    type: "launch" | "ponder";
    account?: Address;
}
declare function useVestingInfo(params: VestingParams, enabled?: boolean): UseQueryResult<DetailedVestingInfo>;

interface ClaimTokensParams {
    tokenAddress: Address;
}
interface ClaimTokensResult {
    hash: Hash;
    amount: bigint;
    events: {
        tokensClaimed?: {
            creator: Address;
            amount: bigint;
        };
    };
}
declare function useClaimTokens(): UseMutationResult<ClaimTokensResult, Error, ClaimTokensParams>;

interface LPWithdrawParams {
    launchId: bigint;
}
interface LPWithdrawResult {
    hash: Hash;
    events: {
        lpWithdrawn?: {
            launchId: bigint;
            creator: Address;
        };
    };
}
interface LPInfo {
    amount: bigint;
    unlockTime: number;
    canWithdraw: boolean;
    timeRemaining?: number;
    token0: Address;
    token1: Address;
    pairAddress: Address;
    totalValue?: bigint;
    token0Amount?: bigint;
    token1Amount?: bigint;
    ponderAmount?: bigint;
    ponderLPAmount?: bigint;
    protocolLPAmount?: bigint;
}
declare function useLPInfo(launchId: bigint, enabled?: boolean): UseQueryResult<LPInfo>;
declare function useLPWithdraw(): UseMutationResult<LPWithdrawResult, Error, LPWithdrawParams>;

interface RemainingToRaise {
    remainingKub: bigint;
    remainingPonder: bigint;
    totalRemaining: bigint;
}
declare function useRemainingToRaise(launchId: bigint, enabled?: boolean): UseQueryResult<RemainingToRaise>;

interface TokenPrice {
    current: number;
    change24h: number;
    change7d: number;
    lastUpdate: number;
    baseAmount: bigint;
    quoteAmount: bigint;
}
declare function usePriceInfo(pairAddress: Address | undefined, tokenIn: Address | undefined, enabled?: boolean): UseQueryResult<TokenPrice>;

interface PricePoint {
    timestamp: number;
    price: number;
    priceUSD: number;
    volume: bigint;
}
interface PriceHistory {
    points: PricePoint[];
    minPrice: number;
    maxPrice: number;
    averagePrice: number;
    totalVolume: bigint;
    percentChange: number;
    currentPrice: number;
}
interface UsePriceHistoryParams {
    pairAddress: Address | undefined;
    tokenIn: Address | undefined;
    period: "1h" | "24h" | "7d" | "30d";
    enabled?: boolean;
    refetchInterval?: number;
}
declare function usePriceHistory({ pairAddress, tokenIn, period, enabled, refetchInterval, }: UsePriceHistoryParams): UseQueryResult<PriceHistory>;

interface OracleStatus {
    lastUpdate: number;
    observationsCount: bigint;
    needsUpdate: boolean;
    nextUpdateTime: number;
}
interface UpdateOracleParams {
    pair: PonderPair;
}
interface UpdateOracleResult {
    hash: Hash;
    timestamp: number;
}
declare function useOracleStatus(pairAddress: Address | undefined, enabled?: boolean): UseQueryResult<OracleStatus>;
declare function useUpdateOracle(): UseMutationResult<UpdateOracleResult, Error, UpdateOracleParams>;

interface AggregatedPrice {
    token: Address;
    price: number;
    confidence: number;
    sources: {
        twap: number;
        spot: number;
        impact: number;
    };
}
declare function usePriceFeeds(pairs: PonderPair[], quoteToken: Address, enabled?: boolean): UseQueryResult<Record<string, AggregatedPrice>>;

interface PoolYield {
    poolId: number;
    pair: Address;
    apr: number;
    apy: number;
    rewardsPerDay: bigint;
    tvl: bigint;
    boostedApr?: number;
    ponderRequired: bigint;
}
interface YieldAnalytics {
    pools: PoolYield[];
    aggregatedMetrics: {
        totalStaked: bigint;
        totalPonderStaked: bigint;
        averageApr: number;
        totalRewardsPerDay: bigint;
        stakerCount: number;
        averageBoostMultiplier: number;
    };
}
declare function useYieldAnalytics(enabled?: boolean): UseQueryResult<YieldAnalytics>;

interface Swap {
    hash: Hash;
    timestamp: number;
    pair: Address;
    sender: Address;
    recipient: Address;
    amountIn: bigint;
    amountOut: bigint;
    tokenIn: Address;
    tokenOut: Address;
    priceImpact: number;
    valueUSD?: number;
    tokenInSymbol?: string;
    tokenOutSymbol?: string;
}
interface UseRecentSwapsParams {
    pair?: Address;
    account?: Address;
    limit?: number;
    fromBlock?: bigint;
}
declare function useRecentSwaps(params?: UseRecentSwapsParams, enabled?: boolean): UseQueryResult<Swap[]>;

type TransactionState = "pending" | "confirmed" | "failed";
interface TransactionStatus {
    state: TransactionState;
    receipt?: TransactionReceipt;
    confirmations: number;
    error?: Error;
    isLoading: boolean;
    isError: boolean;
    isSuccess: boolean;
}
declare function useTransaction(hash: Hash | undefined, confirmations?: number, enabled?: boolean): UseQueryResult<TransactionStatus>;

interface GasEstimateParams {
    to: Address;
    data: `0x${string}`;
    value?: bigint;
}
interface GasEstimate {
    estimate: bigint;
    estimateInKUB: string;
    maxFeePerGas: bigint | null;
    maxPriorityFeePerGas: bigint | null;
    gasPrice: bigint | null;
    isHighPriority?: boolean;
}
declare function useGasEstimate(params: GasEstimateParams | undefined, enabled?: boolean): UseQueryResult<GasEstimate>;

interface SwapCallbackParams {
    route?: SwapRoute;
    recipient?: Address;
    slippageBps?: number;
    deadline?: bigint;
    exactIn?: boolean;
}
interface SwapCalldata {
    to: Address;
    data: `0x${string}`;
    value: bigint;
    gasLimit: bigint;
}
declare function useSwapCallback(params: SwapCallbackParams): {
    calldata: SwapCalldata | null;
    error?: string;
};

interface StakingInfo {
    totalStaked: bigint;
    exchangeRate: number;
    lastRebaseTime: bigint;
    nextRebaseTime: bigint;
    minimumFirstStake: bigint;
    userBalance: bigint;
    userShares: bigint;
    pendingFees: bigint;
    effectiveRate: number;
    owner: Address;
    pendingOwner: Address | undefined;
}
declare function useStakingInfo(address?: Address): _tanstack_react_query.UseQueryResult<StakingInfo, Error>;

interface StakeParams {
    amount: bigint;
    recipient?: Address;
}
declare function useStakePonder(): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, StakeParams, unknown>;

interface UnstakeParams {
    shares: bigint;
}
declare function useUnstakePonder(): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, UnstakeParams, unknown>;

interface StakingStats {
    totalStaked: bigint;
    totalStakers: number;
    averageStakeSize: bigint;
    minimumFirstStake: bigint;
    lastRebase: bigint;
    nextRebase: bigint;
    averageRebaseAmount: bigint;
    valueGrowth24h: number;
    valueGrowth7d: number;
    valueGrowth30d: number;
    topStakers: Array<{
        address: Address;
        stakedAmount: bigint;
        percentageOfTotal: number;
    }>;
}
declare function useStakingStats(): _tanstack_react_query.UseQueryResult<StakingStats, Error>;

declare function useClaimFees(): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, void, unknown>;

interface TokenFeesInfo {
    token: Address;
    symbol: string;
    balance: bigint;
    valueInKUB?: bigint;
}
interface FeeDistributorInfo {
    pendingFees: {
        ponder: bigint;
        otherTokens: TokenFeesInfo[];
    };
    lastDistribution: bigint;
    nextDistribution: bigint;
    minimumAmount: bigint;
    owner: Address;
    totalDistributed24h?: bigint;
    distributionCount24h?: number;
}
declare function useFeeDistributorInfo(enabled?: boolean): _tanstack_react_query.UseQueryResult<FeeDistributorInfo, Error>;

declare function useDistributeFees(): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, void, unknown>;

interface CollectFeesParams {
    pair: Address;
}
declare function useCollectFees(): _tanstack_react_query.UseMutationResult<`0x${string}`, Error, CollectFeesParams, unknown>;

interface TokenMetrics {
    token: Address;
    symbol: string;
    totalCollected: bigint;
    totalConverted: bigint;
    valueInKUB: bigint;
}
interface FeeMetrics {
    totalDistributed: bigint;
    daily: {
        distributions: number;
        volume: bigint;
        avgDistributionSize: bigint;
    };
    weekly: {
        distributions: number;
        volume: bigint;
        avgDistributionSize: bigint;
    };
    monthly: {
        distributions: number;
        volume: bigint;
        avgDistributionSize: bigint;
    };
    tokenMetrics: TokenMetrics[];
    projectedAnnualFees: bigint;
    averageDistributionTime: bigint;
    revenueGrowth: {
        daily: number;
        weekly: number;
        monthly: number;
    };
}
declare function useFeeMetrics(enabled?: boolean): _tanstack_react_query.UseQueryResult<FeeMetrics, Error>;

interface SDKConfig {
    chainId: SupportedChainId;
    publicClient?: PublicClient;
    walletClient?: WalletClient;
}
declare class PonderSDK {
    readonly chainId: SupportedChainId;
    readonly chain: ReturnType<typeof getChainFromId>;
    readonly publicClient: PublicClient;
    private _walletClient?;
    private _factory;
    private _router;
    private _masterChef;
    private _launcher;
    private _oracle;
    private _kkubUnwrapper;
    private _pairs;
    private _launchTokens;
    private _ponder;
    private _staking;
    private _feeDistributor;
    private _bridge;
    constructor({ chainId, publicClient, walletClient }: SDKConfig);
    get factory(): Factory;
    get router(): Router;
    get masterChef(): MasterChef;
    get launcher(): FiveFiveFiveLauncher;
    get oracle(): PriceOracle;
    get kkubUnwrapper(): KKUBUnwrapper;
    get ponder(): Pondertoken;
    get staking(): Staking;
    get feeDistributor(): FeeDistributor;
    get bridge(): Bridge;
    get walletClient(): WalletClient | undefined;
    getPair(pairAddress: Address): Pair;
    getLaunchToken(tokenAddress: Address): LaunchToken;
    updateWalletClient(walletClient?: WalletClient): void;
    getPairByTokens(tokenA: Address, tokenB: Address): Promise<Pair>;
    unwrapKKUB(amount: bigint, recipient: Address): Promise<Hash>;
}

export { type AddLiquidityETHParams, type AddLiquidityParams$2 as AddLiquidityParams, type AddPoolParams, type AggregatedPrice, type AllowanceData, Bridge, type BridgeInfo, type BridgeParams, type ChainIDAndAllowedDestTokenTypes, type CreateLaunchParams$1 as CreateLaunchParams, DEST_TOKEN_TYPE, type DetailedLaunchInfo, type DetailedPoolInfo, type DetailedStakeInfo, type DetailedVestingInfo, FEE_TYPE, Factory, type FarmMetrics, FeeDistributor, type FeeDistributorInfo, type FeeInfo, type FeeMetrics, FiveFiveFiveLauncher, type GasEstimate, KKUBUnwrapper, KKUB_ADDRESS, type LaunchInfo, LaunchToken, type LiquidityPosition, MasterChef, type NativeBridgeParams, type Observation, Pair, type PairCreationData, type PairExistsResult, type PairInfo, type PairLiquidity, type PairQuote, type PairSummary, type PendingRewards, type PonderBridge, type PonderFactory, type PonderFeeDistributor, type PonderKKUBUnwrapper, type PonderLaunchToken, type PonderLauncher, type PonderMasterChef, type PonderPair, type PonderPriceOracle, PonderProvider, type PonderRouter, PonderSDK, type SDKConfig as PonderSDKConfig, type PonderStaking, type PonderToken, Pondertoken, type PoolInfo$1 as PoolInfo, type PositionValue, type PriceHistory, PriceOracle, type RemainingToRaise, type RemoveLiquidityETHParams, type RemoveLiquidityParams$2 as RemoveLiquidityParams, type Reserves, Router, SUPPORTED_CHAINS, type SaleInfo, Staking, type StakingInfo, type StakingStats, type SupportedChainId, type Swap, type SwapExactTokensForTokensParams$1 as SwapExactTokensForTokensParams, type SwapResult, type SwapRoute, type SwapTokensForExactTokensParams$1 as SwapTokensForExactTokensParams, TOKEN_STRATEGY, type TokenInfo, type TokenPrice, type TransactionStatus, type UserInfo, type VestingInfo, type YieldAnalytics, useAddLiquidity, useAllPairs, useAmountIn, useAmountOut, useBoostStake, useBoostUnstake, useClaimFees, useClaimTokens, useCollectFees, useContribute, useCreateLaunch, useDistributeFees, useFarmMetrics, useFeeDistributorInfo, useFeeMetrics, useGasEstimate, useHarvest, useLPInfo, useLPTokenBalance, useLPWithdraw, useLaunchInfo, useOracleStatus, usePairCreation, usePairExists, usePairFees, usePairInfo, usePairLiquidity, usePairQuote, usePendingRewards, usePonderSDK, usePoolInfo, usePositionValue, usePriceFeeds, usePriceHistory, usePriceInfo, useRecentSwaps, useRemainingToRaise, useRemoveLiquidity, useStake, useStakeInfo, useStakePonder, useStakingInfo, useStakingStats, useSwap, useSwapApproval, useSwapCallback, useSwapRoute, useTokenAllowance, useTokenApproval, useTokenBalance, useTokenInfo, useTradeInfo, useTransaction, useUnstake, useUnstakePonder, useUpdateOracle, useVestingInfo, useYieldAnalytics };