@whetstone-research/doppler-sdk 1.0.2 → 1.0.4

package/dist/solana/react/index.d.cts

@@ -0,0 +1,1046 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Rpc, SolanaRpcApi, Address, TransactionSigner } from '@solana/kit';
+import { WalletAccount, Wallet } from '@wallet-standard/base';
+import { StandardConnectFeature, StandardDisconnectFeature } from '@wallet-standard/features';
+import { P as Pool, m as SwapQuote, l as SwapDirection, o as AddLiquidityQuote, p as RemoveLiquidityQuote, a as Position, L as PositionValue, N as PositionWithAddress, O as OracleState, $ as TwapResult, D as OracleWithAddress } from '../../oracle-CU-nZnja.cjs';
+
+/**
+ * Configuration for the AMM provider
+ */
+interface AmmConfig {
+    /** Solana RPC client */
+    rpc: Rpc<SolanaRpcApi>;
+    /** CPMM Program ID (defaults to mainnet program) */
+    programId?: Address;
+    /** Default commitment level for queries */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Auto-refresh interval in milliseconds (0 to disable) */
+    refreshInterval?: number;
+    /** Default slippage tolerance in basis points (default: 50 = 0.5%) */
+    defaultSlippageBps?: number;
+}
+/**
+ * Context value provided to consumers
+ */
+interface AmmContextValue$1 extends Required<Omit<AmmConfig, 'rpc'>> {
+    /** Solana RPC client */
+    rpc: Rpc<SolanaRpcApi>;
+}
+declare const AmmContext$1: react.Context<AmmContextValue$1 | null>;
+/**
+ * Props for the AmmProvider component
+ */
+interface AmmProviderProps$1 extends AmmConfig {
+    children: ReactNode;
+}
+/**
+ * Provider component for CPMM SDK hooks
+ *
+ * @example
+ * ```tsx
+ * import { createSolanaRpc } from '@solana/kit';
+ *
+ * const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+ *
+ * function App() {
+ *   return (
+ *     <AmmProvider rpc={rpc}>
+ *       <YourApp />
+ *     </AmmProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function AmmProvider$1({ rpc, programId, commitment, refreshInterval, defaultSlippageBps, children, }: AmmProviderProps$1): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the AMM context
+ *
+ * @throws Error if used outside of AmmProvider
+ */
+declare function useAmm$1(): AmmContextValue$1;
+/**
+ * Hook to access the AMM context, returning null if not available
+ */
+declare function useAmmOptional(): AmmContextValue$1 | null;
+
+/**
+ * Wallet state and capabilities
+ */
+interface WalletState {
+    /** Whether a wallet is connected */
+    connected: boolean;
+    /** Connected wallet address (undefined if not connected) */
+    address?: Address;
+    /** Transaction signer (undefined if not connected) */
+    signer?: TransactionSigner;
+    /** Connect wallet function */
+    connect?: () => Promise<void>;
+    /** Disconnect wallet function */
+    disconnect?: () => Promise<void>;
+}
+/**
+ * Context value provided to consumers
+ */
+interface WalletContextValue$1 extends WalletState {
+    /** Sign and send a transaction */
+    signAndSendTransaction?: (transaction: unknown) => Promise<string>;
+}
+declare const WalletContext$1: react.Context<WalletContextValue$1 | null>;
+/**
+ * Props for the WalletProvider component
+ */
+interface WalletProviderProps$1 {
+    /** Wallet state from your wallet adapter */
+    wallet: WalletState;
+    /** Optional sign and send transaction handler */
+    signAndSendTransaction?: WalletContextValue$1['signAndSendTransaction'];
+    children: ReactNode;
+}
+/**
+ * Provider component for wallet state
+ *
+ * This provider wraps your existing wallet adapter to provide
+ * a consistent interface for CPMM SDK hooks.
+ *
+ * @example
+ * ```tsx
+ * // With @solana/wallet-adapter-react
+ * import { useWallet } from '@solana/wallet-adapter-react';
+ *
+ * function WalletBridge({ children }) {
+ *   const { connected, publicKey, signTransaction } = useWallet();
+ *
+ *   const wallet = useMemo(() => ({
+ *     connected,
+ *     address: publicKey?.toBase58() as Address | undefined,
+ *     signer: signTransaction ? { signTransactions: async (txs) => txs.map(signTransaction) } : undefined,
+ *   }), [connected, publicKey, signTransaction]);
+ *
+ *   return (
+ *     <WalletProvider wallet={wallet}>
+ *       {children}
+ *     </WalletProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WalletProvider$1({ wallet, signAndSendTransaction, children, }: WalletProviderProps$1): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the wallet context
+ *
+ * @throws Error if used outside of WalletProvider
+ */
+declare function useWallet$1(): WalletContextValue$1;
+/**
+ * Hook to access the wallet context, returning null if not available
+ */
+declare function useWalletOptional(): WalletContextValue$1 | null;
+/**
+ * Hook to get connected wallet address
+ *
+ * @throws Error if wallet is not connected
+ */
+declare function useWalletAddress(): Address;
+
+/**
+ * Commitment level for RPC requests
+ */
+type Commitment = 'processed' | 'confirmed' | 'finalized';
+/**
+ * AMM context value exposed to consumers
+ */
+interface AmmContextValue {
+    /** RPC client for Solana interactions */
+    rpc: Rpc<SolanaRpcApi>;
+    /** RPC endpoint URL */
+    endpoint: string;
+    /** CPMM program ID */
+    programId: Address;
+    /** Default commitment level */
+    commitment: Commitment;
+    /** Auto-refresh interval in milliseconds (0 to disable) */
+    refreshInterval: number;
+    /** Default slippage tolerance in basis points */
+    defaultSlippageBps: number;
+}
+/**
+ * Props for AmmProvider component
+ */
+interface AmmProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Solana RPC endpoint URL */
+    endpoint: string;
+    /** Custom CPMM program ID (defaults to mainnet program) */
+    programId?: Address;
+    /** Default commitment level (defaults to 'confirmed') */
+    commitment?: Commitment;
+    /** Auto-refresh interval in milliseconds (defaults to 30000) */
+    refreshInterval?: number;
+    /** Default slippage tolerance in basis points (defaults to 50 = 0.5%) */
+    defaultSlippageBps?: number;
+}
+/**
+ * Configuration for creating AMM context value
+ */
+interface AmmContextConfig {
+    /** Solana RPC endpoint URL */
+    endpoint: string;
+    /** Custom CPMM program ID */
+    programId?: Address;
+    /** Default commitment level */
+    commitment?: Commitment;
+    /** Auto-refresh interval in milliseconds */
+    refreshInterval?: number;
+    /** Default slippage tolerance in basis points */
+    defaultSlippageBps?: number;
+}
+/**
+ * React context for AMM configuration
+ */
+declare const AmmContext: react.Context<AmmContextValue | null>;
+/**
+ * Hook to access AMM context
+ *
+ * @returns AMM context value with RPC client and configuration
+ * @throws Error if used outside AmmProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { rpc, programId } = useAmm();
+ *   // Use rpc to fetch pool data, etc.
+ * }
+ * ```
+ */
+declare function useAmm(): AmmContextValue;
+/**
+ * Create AMM context value from configuration
+ *
+ * This is exposed for testing purposes and internal use.
+ *
+ * @param config - Configuration for the AMM context
+ * @returns AMM context value
+ */
+declare function createAmmContextValue(config: AmmContextConfig): AmmContextValue;
+/**
+ * AMM Provider component
+ *
+ * Provides RPC connection and program configuration to child components.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <AmmProvider endpoint="https://api.mainnet-beta.solana.com">
+ *       <SwapForm />
+ *     </AmmProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With custom program ID:
+ * ```tsx
+ * import { address } from '@solana/kit';
+ *
+ * function App() {
+ *   return (
+ *     <AmmProvider
+ *       endpoint="https://api.devnet.solana.com"
+ *       programId={address('DevnetProgramId...')}
+ *       commitment="confirmed"
+ *     >
+ *       <SwapForm />
+ *     </AmmProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function AmmProvider({ children, endpoint, programId, commitment, refreshInterval, defaultSlippageBps, }: AmmProviderProps): JSX.Element;
+
+/**
+ * Wallet with required Solana features
+ */
+type SolanaWallet = Wallet & {
+    features: StandardConnectFeature & Partial<StandardDisconnectFeature>;
+};
+/**
+ * Wallet context value exposed to consumers
+ */
+interface WalletContextValue {
+    /** Currently selected wallet (null if none selected) */
+    wallet: SolanaWallet | null;
+    /** Currently connected account (null if not connected) */
+    account: WalletAccount | null;
+    /** Whether a wallet is currently connected */
+    connected: boolean;
+    /** Whether connection is in progress */
+    connecting: boolean;
+    /** List of available wallets */
+    wallets: readonly SolanaWallet[];
+    /** Select a wallet for connection */
+    select: (wallet: SolanaWallet | null) => void;
+    /** Connect to the selected wallet */
+    connect: () => Promise<void>;
+    /** Disconnect from the current wallet */
+    disconnect: () => Promise<void>;
+    /** Error from last operation */
+    error: Error | null;
+}
+/**
+ * Props for WalletProvider component
+ */
+interface WalletProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Auto-connect to previously connected wallet */
+    autoConnect?: boolean;
+    /** Callback when wallet connects */
+    onConnect?: (account: WalletAccount) => void;
+    /** Callback when wallet disconnects */
+    onDisconnect?: () => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * React context for wallet state
+ */
+declare const WalletContext: react.Context<WalletContextValue | null>;
+/**
+ * Hook to access wallet context
+ *
+ * @returns Wallet context value with connection state and methods
+ * @throws Error if used outside WalletProvider
+ *
+ * @example
+ * ```tsx
+ * function ConnectButton() {
+ *   const { connected, connect, disconnect, account } = useWallet();
+ *
+ *   if (connected) {
+ *     return (
+ *       <button onClick={disconnect}>
+ *         Disconnect {account?.address.slice(0, 8)}...
+ *       </button>
+ *     );
+ *   }
+ *
+ *   return <button onClick={connect}>Connect Wallet</button>;
+ * }
+ * ```
+ */
+declare function useWallet(): WalletContextValue;
+/**
+ * Create initial wallet context value
+ *
+ * This is exposed for testing purposes.
+ */
+declare function createWalletContextValue(): WalletContextValue;
+/**
+ * Wallet Provider component
+ *
+ * Provides wallet connection state and methods to child components.
+ * Uses the wallet-standard API for cross-wallet compatibility.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <WalletProvider autoConnect>
+ *       <AmmProvider endpoint="https://api.mainnet-beta.solana.com">
+ *         <SwapForm />
+ *       </AmmProvider>
+ *     </WalletProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With callbacks:
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <WalletProvider
+ *       onConnect={(account) => console.log('Connected:', account.address)}
+ *       onDisconnect={() => console.log('Disconnected')}
+ *       onError={(err) => console.error('Wallet error:', err)}
+ *     >
+ *       <YourApp />
+ *     </WalletProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WalletProvider({ children, autoConnect, onConnect, onDisconnect, onError, }: WalletProviderProps): JSX.Element;
+
+/**
+ * usePool Hook
+ *
+ * Fetches and auto-refreshes pool data from the CPMM program.
+ */
+
+/**
+ * Pool data with loading state
+ */
+interface UsePoolResult {
+    /** Pool account data (null if not loaded or not found) */
+    pool: Pool | null;
+    /** Whether the initial load is in progress */
+    loading: boolean;
+    /** Error that occurred during fetching */
+    error: Error | null;
+    /** Manually trigger a refetch */
+    refetch: () => Promise<void>;
+    /** Whether a refetch is in progress */
+    refetching: boolean;
+}
+/**
+ * Options for usePool hook
+ */
+interface UsePoolOptions {
+    /** Override auto-refresh interval (ms). Set to 0 to disable. */
+    refreshInterval?: number;
+    /** Whether to fetch immediately on mount. Default: true */
+    fetchOnMount?: boolean;
+    /** Commitment level override */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+/**
+ * Hook to fetch and auto-refresh pool data
+ *
+ * @param poolAddress - Address of the pool to fetch
+ * @param options - Optional configuration
+ * @returns Pool data with loading/error states
+ *
+ * @example
+ * ```tsx
+ * function PoolInfo({ poolAddress }: { poolAddress: Address }) {
+ *   const { pool, loading, error, refetch } = usePool(poolAddress);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!pool) return <div>Pool not found</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Reserve 0: {pool.reserve0.toString()}</p>
+ *       <p>Reserve 1: {pool.reserve1.toString()}</p>
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePool(poolAddress: Address | undefined, options?: UsePoolOptions): UsePoolResult;
+/**
+ * Hook to fetch multiple pools
+ *
+ * @param poolAddresses - Array of pool addresses to fetch
+ * @param options - Optional configuration
+ * @returns Map of pool address to pool data
+ */
+declare function usePools(poolAddresses: Address[], options?: UsePoolOptions): {
+    pools: Map<Address, Pool>;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+/**
+ * useSwap Hook
+ *
+ * Provides swap quote calculations and execution for the CPMM program.
+ */
+
+/**
+ * Swap state
+ */
+interface SwapState {
+    /** Input token address */
+    inputToken: Address | null;
+    /** Output token address */
+    outputToken: Address | null;
+    /** Input amount (raw bigint) */
+    inputAmount: bigint;
+    /** Output amount (raw bigint) */
+    outputAmount: bigint;
+    /** Whether input is exact (vs exact output) */
+    exactInput: boolean;
+    /** Slippage tolerance in basis points */
+    slippageBps: number;
+}
+/**
+ * Swap quote with additional computed fields
+ */
+interface SwapQuoteResult extends SwapQuote {
+    /** Minimum output amount (after slippage) */
+    minAmountOut: bigint;
+    /** Maximum input amount (after slippage, for exact output) */
+    maxAmountIn: bigint;
+    /** Swap direction (0 = token0->token1, 1 = token1->token0) */
+    direction: SwapDirection;
+    /** Whether the quote is valid */
+    isValid: boolean;
+    /** Error message if invalid */
+    error: string | null;
+}
+/**
+ * Result from useSwap hook
+ */
+interface UseSwapResult {
+    /** Current swap state */
+    state: SwapState;
+    /** Computed quote based on current state */
+    quote: SwapQuoteResult | null;
+    /** Whether a quote calculation is in progress */
+    quoting: boolean;
+    /** Set input token */
+    setInputToken: (token: Address | null) => void;
+    /** Set output token */
+    setOutputToken: (token: Address | null) => void;
+    /** Set input amount */
+    setInputAmount: (amount: bigint) => void;
+    /** Set output amount (switches to exact output mode) */
+    setOutputAmount: (amount: bigint) => void;
+    /** Set slippage tolerance */
+    setSlippage: (bps: number) => void;
+    /** Swap input and output tokens */
+    flipTokens: () => void;
+    /** Reset all state */
+    reset: () => void;
+    /** Whether swap can be executed */
+    canSwap: boolean;
+}
+/**
+ * Options for useSwap hook
+ */
+interface UseSwapOptions {
+    /** Initial slippage tolerance in basis points (default: 50 = 0.5%) */
+    defaultSlippageBps?: number;
+    /** Pool to swap on */
+    pool: Pool | null;
+    /** Token0 mint address */
+    token0Mint: Address | null;
+    /** Token1 mint address */
+    token1Mint: Address | null;
+}
+/**
+ * Hook for swap quote calculation and state management
+ *
+ * @param options - Configuration options
+ * @returns Swap state and helpers
+ *
+ * @example
+ * ```tsx
+ * function SwapInterface({ pool }: { pool: Pool }) {
+ *   const {
+ *     state,
+ *     quote,
+ *     setInputAmount,
+ *     setInputToken,
+ *     setOutputToken,
+ *     flipTokens,
+ *   } = useSwap({
+ *     pool,
+ *     token0Mint: pool.token0Mint,
+ *     token1Mint: pool.token1Mint,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         type="number"
+ *         onChange={(e) => setInputAmount(BigInt(e.target.value))}
+ *       />
+ *       {quote && (
+ *         <div>
+ *           Output: {quote.amountOut.toString()}
+ *           Price Impact: {(quote.priceImpact * 100).toFixed(2)}%
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSwap(options: UseSwapOptions): UseSwapResult;
+
+/**
+ * useLiquidity Hook
+ *
+ * Provides liquidity quote calculations for adding/removing liquidity.
+ */
+
+/**
+ * Liquidity operation mode
+ */
+type LiquidityMode = 'add' | 'remove';
+/**
+ * Add liquidity state
+ */
+interface AddLiquidityState {
+    /** Amount of token0 to deposit */
+    amount0: bigint;
+    /** Amount of token1 to deposit */
+    amount1: bigint;
+    /** Slippage tolerance in basis points */
+    slippageBps: number;
+}
+/**
+ * Remove liquidity state
+ */
+interface RemoveLiquidityState {
+    /** Shares to burn */
+    shares: bigint;
+    /** Percentage of position to remove (0-100) */
+    percentage: number;
+    /** Slippage tolerance in basis points */
+    slippageBps: number;
+}
+/**
+ * Add liquidity quote with computed fields
+ */
+interface AddLiquidityQuoteResult extends AddLiquidityQuote {
+    /** Minimum shares to receive (after slippage) */
+    minSharesOut: bigint;
+    /** Whether the quote is valid */
+    isValid: boolean;
+    /** Error message if invalid */
+    error: string | null;
+}
+/**
+ * Remove liquidity quote with computed fields
+ */
+interface RemoveLiquidityQuoteResult extends RemoveLiquidityQuote {
+    /** Minimum token0 to receive (after slippage) */
+    minAmount0Out: bigint;
+    /** Minimum token1 to receive (after slippage) */
+    minAmount1Out: bigint;
+    /** Whether the quote is valid */
+    isValid: boolean;
+    /** Error message if invalid */
+    error: string | null;
+}
+/**
+ * Result from useLiquidity hook
+ */
+interface UseLiquidityResult {
+    /** Current mode (add or remove) */
+    mode: LiquidityMode;
+    /** Set mode */
+    setMode: (mode: LiquidityMode) => void;
+    /** Add liquidity state */
+    addState: AddLiquidityState;
+    /** Add liquidity quote */
+    addQuote: AddLiquidityQuoteResult | null;
+    /** Set amount0 for add */
+    setAmount0: (amount: bigint) => void;
+    /** Set amount1 for add */
+    setAmount1: (amount: bigint) => void;
+    /** Whether can add liquidity */
+    canAdd: boolean;
+    /** Remove liquidity state */
+    removeState: RemoveLiquidityState;
+    /** Remove liquidity quote */
+    removeQuote: RemoveLiquidityQuoteResult | null;
+    /** Set shares for remove */
+    setShares: (shares: bigint) => void;
+    /** Set percentage for remove (calculates shares from position) */
+    setPercentage: (percentage: number) => void;
+    /** Whether can remove liquidity */
+    canRemove: boolean;
+    /** Set slippage tolerance */
+    setSlippage: (bps: number) => void;
+    /** Reset all state */
+    reset: () => void;
+}
+/**
+ * Options for useLiquidity hook
+ */
+interface UseLiquidityOptions {
+    /** Pool to add/remove liquidity from */
+    pool: Pool | null;
+    /** User's current position shares (for remove percentage calculation) */
+    userShares?: bigint;
+    /** Initial slippage tolerance in basis points (default: 50 = 0.5%) */
+    defaultSlippageBps?: number;
+    /** Initial mode */
+    defaultMode?: LiquidityMode;
+}
+/**
+ * Hook for liquidity quote calculation and state management
+ *
+ * @param options - Configuration options
+ * @returns Liquidity state and helpers
+ *
+ * @example
+ * ```tsx
+ * function LiquidityInterface({ pool, position }) {
+ *   const {
+ *     mode,
+ *     setMode,
+ *     addState,
+ *     addQuote,
+ *     setAmount0,
+ *     removeState,
+ *     removeQuote,
+ *     setPercentage,
+ *   } = useLiquidity({
+ *     pool,
+ *     userShares: position?.shares,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => setMode('add')}>Add</button>
+ *       <button onClick={() => setMode('remove')}>Remove</button>
+ *
+ *       {mode === 'add' && addQuote && (
+ *         <div>Shares out: {addQuote.sharesOut.toString()}</div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLiquidity(options: UseLiquidityOptions): UseLiquidityResult;
+
+/**
+ * usePosition Hook
+ *
+ * Fetches and manages user position data from the CPMM program.
+ */
+
+/**
+ * Position data with calculated values
+ */
+interface UsePositionResult {
+    /** Position account data (null if not loaded or not found) */
+    position: Position | null;
+    /** Position address */
+    positionAddress?: Address;
+    /** Whether the initial load is in progress */
+    loading: boolean;
+    /** Error that occurred during fetching */
+    error: Error | null;
+    /** Manually trigger a refetch */
+    refetch: () => Promise<void>;
+    /** Pending uncollected fees */
+    pendingFees: {
+        pending0: bigint;
+        pending1: bigint;
+    } | null;
+    /** Position value breakdown (requires pool data) */
+    value: PositionValue | null;
+}
+/**
+ * Options for usePosition hook
+ */
+interface UsePositionOptions {
+    /** Override auto-refresh interval (ms). Set to 0 to disable. */
+    refreshInterval?: number;
+    /** Whether to fetch immediately on mount. Default: true */
+    fetchOnMount?: boolean;
+    /** Commitment level override */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Pool data (if already fetched) to calculate position value */
+    pool?: Pool;
+}
+/**
+ * Hook to fetch user's position in a pool
+ *
+ * @param poolAddress - Address of the pool
+ * @param positionId - Position ID (default: 0 for first position)
+ * @param options - Optional configuration
+ * @returns Position data with loading/error states
+ *
+ * @example
+ * ```tsx
+ * function MyPosition({ poolAddress }: { poolAddress: Address }) {
+ *   const { position, loading, error, pendingFees, value } = usePosition(poolAddress);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (!position) return <div>No position found</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Shares: {position.shares.toString()}</p>
+ *       {pendingFees && (
+ *         <p>Pending fees: {pendingFees.pending0.toString()} / {pendingFees.pending1.toString()}</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePosition(poolAddress: Address | undefined, positionId?: bigint, options?: UsePositionOptions): UsePositionResult;
+/**
+ * Result for useUserPositions hook
+ */
+interface UseUserPositionsResult {
+    /** Array of user positions with addresses */
+    positions: PositionWithAddress[];
+    /** Whether loading */
+    loading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Manually trigger refetch */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to fetch all positions for the connected user
+ *
+ * @param poolFilter - Optional pool address to filter positions
+ * @param options - Optional configuration
+ * @returns Array of user positions
+ *
+ * @example
+ * ```tsx
+ * function AllPositions() {
+ *   const { positions, loading } = useUserPositions();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {positions.map(({ address, account }) => (
+ *         <li key={address}>
+ *           Pool: {account.pool} - Shares: {account.shares.toString()}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useUserPositions(poolFilter?: Address, options?: Omit<UsePositionOptions, 'pool'>): UseUserPositionsResult;
+
+/**
+ * useFees Hook
+ *
+ * Calculates and tracks pending fees for a user's position, with collection capability.
+ */
+
+/**
+ * Transaction status
+ */
+type TransactionStatus = 'idle' | 'signing' | 'sending' | 'confirming' | 'success' | 'error';
+/**
+ * Pending fees data
+ */
+interface PendingFees {
+    /** Pending fees in token0 */
+    pending0: bigint;
+    /** Pending fees in token1 */
+    pending1: bigint;
+    /** Whether there are any fees to collect */
+    hasFees: boolean;
+}
+/**
+ * Options for collecting fees
+ */
+interface CollectFeesOptions {
+    /** Maximum amount of token0 to collect (default: all) */
+    max0?: bigint;
+    /** Maximum amount of token1 to collect (default: all) */
+    max1?: bigint;
+    /** User's token0 account */
+    userToken0: Address;
+    /** User's token1 account */
+    userToken1: Address;
+}
+/**
+ * Result from useFees hook
+ */
+interface UseFeesResult {
+    /** Pending fees data */
+    fees: PendingFees | null;
+    /** Whether loading */
+    loading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Manually trigger refetch */
+    refetch: () => Promise<void>;
+    /** Whether a refetch is in progress */
+    refetching: boolean;
+    /** Collect pending fees */
+    collect: (options: CollectFeesOptions) => Promise<string>;
+    /** Current transaction status */
+    status: TransactionStatus;
+    /** Transaction error */
+    txError: Error | null;
+    /** Last transaction signature */
+    txSignature: string | null;
+    /** Reset transaction status */
+    reset: () => void;
+    /** Whether fees can be collected */
+    canCollect: boolean;
+}
+/**
+ * Options for useFees hook
+ */
+interface UseFeesOptions {
+    /** Override auto-refresh interval (ms). Set to 0 to disable. */
+    refreshInterval?: number;
+    /** Whether to fetch immediately on mount. Default: true */
+    fetchOnMount?: boolean;
+    /** Commitment level override */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Pre-fetched pool data */
+    pool?: Pool | null;
+    /** Pre-fetched position data */
+    position?: Position | null;
+}
+/**
+ * Hook to calculate and track pending fees for a position
+ *
+ * @param positionAddress - Address of the position
+ * @param poolAddress - Address of the pool (needed if position not provided)
+ * @param options - Optional configuration
+ * @returns Pending fees with loading/error states
+ *
+ * @example
+ * ```tsx
+ * function PositionFees({ positionAddress, poolAddress }: Props) {
+ *   const { fees, loading, refetch } = useFees(positionAddress, poolAddress);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (!fees) return <div>No fees data</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Token0 fees: {fees.pending0.toString()}</p>
+ *       <p>Token1 fees: {fees.pending1.toString()}</p>
+ *       {fees.hasFees && <button onClick={() => {}}>Collect Fees</button>}
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFees(positionAddress: Address | undefined, poolAddress: Address | undefined, options?: UseFeesOptions): UseFeesResult;
+/**
+ * Hook to calculate fees from pre-fetched data (no RPC calls)
+ *
+ * @param pool - Pool data
+ * @param position - Position data
+ * @returns Pending fees
+ */
+declare function useFeesFromData(pool: Pool | null | undefined, position: Position | null | undefined): PendingFees | null;
+
+/**
+ * useOracle Hook
+ *
+ * Fetches oracle data and provides TWAP calculations for CPMM pools.
+ */
+
+/**
+ * Oracle data with computed metrics
+ */
+interface UseOracleResult {
+    /** Oracle state data (null if not loaded or not initialized) */
+    oracle: OracleState | null;
+    /** Oracle account address */
+    oracleAddress: Address | null;
+    /** Whether the initial load is in progress */
+    loading: boolean;
+    /** Error that occurred during fetching */
+    error: Error | null;
+    /** Manually trigger a refetch */
+    refetch: () => Promise<void>;
+    /** Calculate TWAP for a given window (seconds) */
+    twap: (windowSeconds: number) => TwapResult | null;
+    /** Current spot prices from oracle */
+    spotPrice: {
+        price0: number;
+        price1: number;
+    } | null;
+    /** Price deviation metrics */
+    deviation: {
+        deviation0: number;
+        deviation1: number;
+    } | null;
+    /** Oracle age in seconds */
+    age: number | null;
+    /** Whether oracle is stale */
+    isStale: (maxAgeSeconds: number) => boolean;
+    /** Buffer statistics */
+    bufferStats: {
+        capacity: number;
+        filledCount: number;
+        currentIndex: number;
+        timeSpanSeconds: number;
+    } | null;
+    /** Compare oracle price with pool spot price (requires pool data) */
+    compareWithPool: (pool: Pool) => {
+        poolPrice0: number;
+        oraclePrice0: number;
+        divergencePct: number;
+    } | null;
+}
+/**
+ * Options for useOracle hook
+ */
+interface UseOracleOptions {
+    /** Override auto-refresh interval (ms). Set to 0 to disable. */
+    refreshInterval?: number;
+    /** Whether to fetch immediately on mount. Default: true */
+    fetchOnMount?: boolean;
+    /** Commitment level override */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+/**
+ * Hook to fetch oracle data and calculate TWAPs
+ *
+ * @param poolAddress - Address of the pool (oracle is derived from pool)
+ * @param options - Optional configuration
+ * @returns Oracle data with TWAP calculations
+ *
+ * @example
+ * ```tsx
+ * function OracleInfo({ poolAddress }: { poolAddress: Address }) {
+ *   const { oracle, loading, twap, spotPrice, age, isStale } = useOracle(poolAddress);
+ *
+ *   if (loading) return <div>Loading oracle...</div>;
+ *   if (!oracle) return <div>Oracle not initialized</div>;
+ *
+ *   const twap5min = twap(300); // 5-minute TWAP
+ *
+ *   return (
+ *     <div>
+ *       <p>Spot Price: {spotPrice?.price0.toFixed(6)}</p>
+ *       <p>5min TWAP: {twap5min?.price0.toFixed(6)}</p>
+ *       <p>Oracle Age: {age}s {isStale(60) && '(STALE)'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useOracle(poolAddress: Address | undefined, options?: UseOracleOptions): UseOracleResult;
+/**
+ * Hook to get TWAP for a specific window with automatic updates
+ *
+ * @param poolAddress - Pool address
+ * @param windowSeconds - TWAP window in seconds
+ * @param options - Optional configuration
+ */
+declare function useTwap(poolAddress: Address | undefined, windowSeconds: number, options?: UseOracleOptions): {
+    twap: TwapResult | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook to fetch oracle data for multiple pools
+ */
+declare function useOracles(poolAddresses: Address[], options?: UseOracleOptions): {
+    oracles: Map<Address, OracleWithAddress>;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+export { type AddLiquidityQuoteResult, type AddLiquidityState, type AmmConfig, AmmContext$1 as AmmContext, type AmmContextConfig, type AmmContextValue$1 as AmmContextValue, AmmProvider$1 as AmmProvider, type AmmProviderProps$1 as AmmProviderProps, type CollectFeesOptions, type Commitment, AmmContext as EndpointAmmContext, type AmmContextValue as EndpointAmmContextValue, AmmProvider as EndpointAmmProvider, type AmmProviderProps as EndpointAmmProviderProps, type LiquidityMode, type PendingFees, type RemoveLiquidityQuoteResult, type RemoveLiquidityState, type SolanaWallet, type SwapQuoteResult, type SwapState, type TransactionStatus, type UseFeesOptions, type UseFeesResult, type UseLiquidityOptions, type UseLiquidityResult, type UseOracleOptions, type UseOracleResult, type UsePoolOptions, type UsePoolResult, type UsePositionOptions, type UsePositionResult, type UseSwapOptions, type UseSwapResult, type UseUserPositionsResult, WalletContext$1 as WalletContext, type WalletContextValue$1 as WalletContextValue, WalletProvider$1 as WalletProvider, type WalletProviderProps$1 as WalletProviderProps, WalletContext as WalletStandardContext, type WalletContextValue as WalletStandardContextValue, WalletProvider as WalletStandardProvider, type WalletProviderProps as WalletStandardProviderProps, type WalletState, createAmmContextValue, createWalletContextValue, useAmm$1 as useAmm, useAmmOptional, useAmm as useEndpointAmm, useFees, useFeesFromData, useLiquidity, useOracle, useOracles, usePool, usePools, usePosition, useWallet as useStandardWallet, useSwap, useTwap, useUserPositions, useWallet$1 as useWallet, useWalletAddress, useWalletOptional };