@whetstone-research/doppler-sdk 0.0.24 → 1.0.1

package/dist/oracle-B2LV97ff.d.ts

@@ -0,0 +1,826 @@
+import { Address, Rpc, GetProgramAccountsApi, GetAccountInfoApi } from '@solana/kit';
+
+/**
+ * Direction of a swap operation
+ * - 0: token0 -> token1 (sell token0 for token1)
+ * - 1: token1 -> token0 (sell token1 for token0)
+ */
+type SwapDirection = 0 | 1;
+/**
+ * Global AMM configuration account
+ * PDA: ['config']
+ */
+interface AmmConfig {
+    /** Admin pubkey with authority over pools */
+    admin: Address;
+    /** Whether all pool operations are paused */
+    paused: boolean;
+    /** Default numeraire mint for pricing */
+    numeraireMint: Address;
+    /** Number of programs in sentinel allowlist */
+    sentinelAllowlistLen: number;
+    /** Allowlist of sentinel programs (fixed size: 32) */
+    sentinelAllowlist: Address[];
+    /** Maximum allowed swap fee in basis points */
+    maxSwapFeeBps: number;
+    /** Maximum allowed fee split in basis points */
+    maxFeeSplitBps: number;
+    /** Maximum number of hops for routing */
+    maxRouteHops: number;
+    /** Whether protocol fees are enabled */
+    protocolFeeEnabled: boolean;
+    /** Protocol fee in basis points (share of LP fees) */
+    protocolFeeBps: number;
+    /** Account version for migrations */
+    version: number;
+    /** Reserved bytes for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Pool account for a trading pair
+ * PDA: ['pool', token0_mint, token1_mint]
+ */
+interface Pool {
+    /** Reference to the AmmConfig account */
+    config: Address;
+    /** Mint of token0 (lexicographically smaller) */
+    token0Mint: Address;
+    /** Mint of token1 (lexicographically larger) */
+    token1Mint: Address;
+    /** Token account holding token0 reserves */
+    vault0: Address;
+    /** Token account holding token1 reserves */
+    vault1: Address;
+    /** PDA authority for vault transfers */
+    authority: Address;
+    /** Bump seed for authority PDA */
+    bump: number;
+    /** Current reserve of token0 (excluding distributable fees) */
+    reserve0: bigint;
+    /** Current reserve of token1 (excluding distributable fees) */
+    reserve1: bigint;
+    /** Total LP shares outstanding (u128) */
+    totalShares: bigint;
+    /** Swap fee in basis points (0-10000) */
+    swapFeeBps: number;
+    /** Fee split: % of swap fee that goes to distributable (vs compounding) */
+    feeSplitBps: number;
+    /** Global fee growth per share for token0 (Q64.64) */
+    feeGrowthGlobal0Q64: bigint;
+    /** Global fee growth per share for token1 (Q64.64) */
+    feeGrowthGlobal1Q64: bigint;
+    /** Unclaimed distributable fees in token0 */
+    feesUnclaimed0: bigint;
+    /** Unclaimed distributable fees in token1 */
+    feesUnclaimed1: bigint;
+    /** Sentinel program for hooks (default = disabled) */
+    sentinelProgram: Address;
+    /** Bitflags for enabled sentinel hooks */
+    sentinelFlags: number;
+    /** Override numeraire mint for this pool */
+    numeraireMint: Address;
+    /** Which token to use for liquidity measure (0 or 1) */
+    liquidityMeasureSide: number;
+    /** Next pool in routing chain (default = none) */
+    routeNextPool: Address;
+    /** Bridge mint for routing (must be token0 or token1) */
+    routeBridgeMint: Address;
+    /** Last k value for protocol fee calculation (u128) */
+    kLast: bigint;
+    /** Protocol position for protocol fee shares */
+    protocolPosition: Address;
+    /** Reentrancy lock (0 = unlocked, 1 = locked) */
+    locked: number;
+    /** Account version for migrations */
+    version: number;
+    /** Reserved bytes for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Position account representing LP ownership
+ * PDA: ['position', pool, owner, position_id]
+ */
+interface Position {
+    /** The pool this position is for */
+    pool: Address;
+    /** Owner of the position */
+    owner: Address;
+    /** Unique position ID for this owner (allows multiple positions) */
+    positionId: bigint;
+    /** Number of LP shares owned (u128) */
+    shares: bigint;
+    /** Checkpoint of fee growth for token0 (Q64.64) */
+    feeGrowthLast0Q64: bigint;
+    /** Checkpoint of fee growth for token1 (Q64.64) */
+    feeGrowthLast1Q64: bigint;
+    /** Accrued uncollected fees in token0 */
+    feeOwed0: bigint;
+    /** Accrued uncollected fees in token1 */
+    feeOwed1: bigint;
+    /** Account version for migrations */
+    version: number;
+    /** Reserved bytes for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Single TWAP observation
+ */
+interface Observation {
+    /** Timestamp of this observation */
+    timestamp: number;
+    /** Cumulative price0 at this timestamp (Q64.64 accumulated, U256) */
+    price0Cumulative: bigint;
+    /** Cumulative price1 at this timestamp (Q64.64 accumulated, U256) */
+    price1Cumulative: bigint;
+}
+/**
+ * Oracle state for TWAP price tracking
+ * PDA: ['oracle', pool]
+ */
+interface OracleState {
+    /** The pool this oracle tracks */
+    pool: Address;
+    /** Whether oracle has been initialized with first observation */
+    initialized: boolean;
+    /** Maximum price change ratio per slot (Q64.64, e.g., 1.1 = 10% max move) */
+    maxPriceChangeRatioQ64: bigint;
+    /** Last slot when oracle was updated */
+    lastSlot: bigint;
+    /** Truncated (clamped) price of token0 in token1 (Q64.64) */
+    truncPrice0Q64: bigint;
+    /** Truncated (clamped) price of token1 in token0 (Q64.64) */
+    truncPrice1Q64: bigint;
+    /** Deviation between spot and truncated price0 (Q64.64) */
+    deviation0Q64: bigint;
+    /** Deviation between spot and truncated price1 (Q64.64) */
+    deviation1Q64: bigint;
+    /** Cumulative truncated price0 (wrapping U256) */
+    price0Cumulative: bigint;
+    /** Cumulative truncated price1 (wrapping U256) */
+    price1Cumulative: bigint;
+    /** Last timestamp when oracle was updated */
+    lastTimestamp: number;
+    /** Last timestamp when an observation was recorded */
+    lastObservationTimestamp: number;
+    /** Minimum seconds between observations */
+    observationIntervalSec: number;
+    /** Current index in circular observation buffer */
+    observationIndex: number;
+    /** Circular buffer of TWAP observations (fixed size: 64) */
+    observations: Observation[];
+    /** Account version for migrations */
+    version: number;
+    /** Reserved bytes for future use */
+    reserved: Uint8Array;
+}
+interface InitializeConfigArgs {
+    admin: Address;
+    numeraireMint: Address;
+    maxSwapFeeBps: number;
+    maxFeeSplitBps: number;
+    maxRouteHops: number;
+    protocolFeeEnabled: boolean;
+    protocolFeeBps: number;
+    sentinelAllowlist: Address[];
+}
+interface InitializePoolArgs {
+    mintA: Address;
+    mintB: Address;
+    initialSwapFeeBps: number;
+    initialFeeSplitBps: number;
+    liquidityMeasureSide: number;
+    numeraireMintOverride: Address | null;
+}
+interface InitializeOracleArgs {
+    maxPriceChangeRatioQ64: bigint;
+    observationIntervalSec: number;
+    numObservations: number;
+}
+interface CreatePositionArgs {
+    positionId: bigint;
+}
+interface AddLiquidityArgs {
+    amount0Max: bigint;
+    amount1Max: bigint;
+    minSharesOut: bigint;
+    updateOracle: boolean;
+}
+interface RemoveLiquidityArgs {
+    sharesIn: bigint;
+    minAmount0Out: bigint;
+    minAmount1Out: bigint;
+    updateOracle: boolean;
+}
+interface SwapExactInArgs {
+    amountIn: bigint;
+    minAmountOut: bigint;
+    direction: SwapDirection;
+    updateOracle: boolean;
+}
+interface CollectFeesArgs {
+    max0: bigint;
+    max1: bigint;
+}
+interface CollectProtocolFeesArgs {
+    max0: bigint;
+    max1: bigint;
+}
+interface SetSentinelArgs {
+    sentinelProgram: Address;
+    sentinelFlags: number;
+}
+interface SetFeesArgs {
+    swapFeeBps: number;
+    feeSplitBps: number;
+}
+interface SetRouteArgs {
+    routeNextPool: Address;
+    routeBridgeMint: Address;
+}
+interface TransferAdminArgs {
+    newAdmin: Address;
+}
+interface OracleConsultArgs {
+    windowSeconds: number;
+}
+interface QuoteToNumeraireArgs {
+    amount: bigint;
+    side: number;
+    maxHops: number;
+    /** Must be false in v0.1 (spot-only) */
+    useTwap: boolean;
+    /** Must be 0 in v0.1 (spot-only) */
+    windowSeconds: number;
+}
+interface SwapQuote {
+    /** Expected output amount */
+    amountOut: bigint;
+    /** Total fee charged (in input token) */
+    feeTotal: bigint;
+    /** Distributable portion of fee */
+    feeDist: bigint;
+    /** Compounding portion of fee */
+    feeComp: bigint;
+    /** Price impact as a decimal (0.01 = 1%) */
+    priceImpact: number;
+    /** Execution price (output/input) */
+    executionPrice: number;
+}
+interface SwapQuoteExactOut {
+    /** Required input amount */
+    amountIn: bigint;
+    /** Total fee charged (in input token) */
+    feeTotal: bigint;
+}
+interface AddLiquidityQuote {
+    /** Shares the user will receive */
+    sharesOut: bigint;
+    /** Actual amount of token0 to deposit */
+    amount0: bigint;
+    /** Actual amount of token1 to deposit */
+    amount1: bigint;
+    /** Share of pool after deposit */
+    poolShare: number;
+}
+interface RemoveLiquidityQuote {
+    /** Amount of token0 to receive */
+    amount0: bigint;
+    /** Amount of token1 to receive */
+    amount1: bigint;
+}
+interface TwapResult {
+    /** TWAP price of token0 in token1 (Q64.64) */
+    price0Q64: bigint;
+    /** TWAP price of token1 in token0 (Q64.64) */
+    price1Q64: bigint;
+    /** TWAP price of token0 in token1 (decimal) */
+    price0: number;
+    /** TWAP price of token1 in token0 (decimal) */
+    price1: number;
+}
+interface SwapEvent {
+    pool: Address;
+    user: Address;
+    direction: SwapDirection;
+    amountIn: bigint;
+    amountOut: bigint;
+    feeTotal: bigint;
+    feeDist: bigint;
+}
+interface AddLiquidityEvent {
+    pool: Address;
+    owner: Address;
+    amount0: bigint;
+    amount1: bigint;
+    sharesOut: bigint;
+}
+interface RemoveLiquidityEvent {
+    pool: Address;
+    owner: Address;
+    amount0: bigint;
+    amount1: bigint;
+    sharesIn: bigint;
+}
+interface CollectFeesEvent {
+    pool: Address;
+    owner: Address;
+    amount0: bigint;
+    amount1: bigint;
+}
+interface CollectProtocolFeesEvent {
+    pool: Address;
+    amount0: bigint;
+    amount1: bigint;
+    recipient0: Address;
+    recipient1: Address;
+}
+interface PoolInitializedEvent {
+    pool: Address;
+    token0Mint: Address;
+    token1Mint: Address;
+    vault0: Address;
+    vault1: Address;
+}
+interface PositionCreatedEvent {
+    pool: Address;
+    owner: Address;
+    position: Address;
+    positionId: bigint;
+}
+interface PositionClosedEvent {
+    pool: Address;
+    owner: Address;
+    position: Address;
+}
+interface SentinelInvokedEvent {
+    pool: Address;
+    action: number;
+    allow: number;
+    newFeeBps: number;
+    newSplitBps: number;
+}
+interface SentinelErrorEvent {
+    pool: Address;
+    action: number;
+    errorCode: bigint;
+}
+interface SentinelUpdatedEvent {
+    pool: Address;
+    sentinelProgram: Address;
+    sentinelFlags: number;
+    admin: Address;
+}
+interface FeesUpdatedEvent {
+    pool: Address;
+    prevSwapFeeBps: number;
+    prevFeeSplitBps: number;
+    swapFeeBps: number;
+    feeSplitBps: number;
+    source: number;
+}
+interface OracleInitializedEvent {
+    pool: Address;
+    maxPriceChangeRatioQ64: bigint;
+    observationIntervalSec: number;
+    admin: Address;
+}
+interface OracleUpdatedEvent {
+    pool: Address;
+    slot: bigint;
+    truncPrice0Q64: bigint;
+    truncPrice1Q64: bigint;
+    deviation0Q64: bigint;
+    deviation1Q64: bigint;
+}
+interface RouteUpdatedEvent {
+    pool: Address;
+    routeNextPool: Address;
+    routeBridgeMint: Address;
+    admin: Address;
+}
+interface AdminTransferredEvent {
+    oldAdmin: Address;
+    newAdmin: Address;
+}
+interface PausedEvent {
+}
+interface UnpausedEvent {
+}
+interface SkimmedEvent {
+    pool: Address;
+    amount0: bigint;
+    amount1: bigint;
+}
+interface MarketCapValidationResult {
+    valid: boolean;
+    warnings: string[];
+}
+interface CurveParams {
+    /** Virtual base token reserves for the XYK curve */
+    curveVirtualBase: bigint;
+    /** Virtual quote token reserves for the XYK curve */
+    curveVirtualQuote: bigint;
+}
+interface MarketCapToCurveParamsInput {
+    /** Starting market cap in USD (price at launch open) */
+    startMarketCapUSD: number;
+    /** Ending market cap in USD (graduation / migration threshold) */
+    endMarketCapUSD: number;
+    /** Total base token supply including all decimals (raw u64) */
+    baseTotalSupply: bigint;
+    /**
+     * Base tokens allocated to the curve vault
+     * (baseTotalSupply - baseForDistribution - baseForLiquidity).
+     * Determines the initial spot price: virtual_quote / (baseForCurve + virtualBase).
+     */
+    baseForCurve: bigint;
+    /** Decimals of the base (launched) token */
+    baseDecimals: number;
+    /** Decimals of the quote (numeraire) token, e.g. 9 for SOL, 6 for USDC */
+    quoteDecimals: number;
+    /** USD price of one unit of the numeraire token (e.g. SOL price in USD) */
+    numerairePriceUSD: number;
+    /**
+     * Virtual base reserve to use as the canonical anchor. Defaults to `baseForCurve`.
+     * Changing this scales `curveVirtualQuote` proportionally — the resulting spot
+     * price is unchanged, but a larger value gives finer integer granularity at the
+     * cost of a proportionally larger `curveVirtualQuote`. Only override if you have
+     * a specific reason; the default is appropriate for most launches.
+     */
+    virtualBase?: bigint;
+}
+interface CurveParamsToMarketCapInput {
+    curveVirtualBase: bigint;
+    curveVirtualQuote: bigint;
+    /**
+     * Base tokens available to the curve (vault balance minus reserved allocations).
+     * Computed as: baseVaultBalance - baseForDistribution - baseForLiquidity.
+     * At launch open this equals baseForCurve.
+     */
+    baseReserve: bigint;
+    /** Current quote token vault balance (raw u64) */
+    quoteReserve: bigint;
+    baseTotalSupply: bigint;
+    baseDecimals: number;
+    quoteDecimals: number;
+    numerairePriceUSD: number;
+}
+
+type ProgramAccountsFilter = NonNullable<NonNullable<Parameters<Rpc<GetProgramAccountsApi>['getProgramAccounts']>[1]>['filters']>[number];
+/**
+ * A minimal RPC interface for getProgramAccounts that is compatible with both
+ * @solana/kit@5 and @solana/kit@6.
+ *
+ * The only breaking difference between the two versions is that kit@6 uses
+ * `readonly` arrays for the `filters` parameter while kit@5 uses mutable arrays.
+ * Declaring `filters` as a mutable array here satisfies both kit versions via
+ * TypeScript's function parameter contravariance: a function that accepts
+ * `readonly` inputs (kit@6) is a subtype of one that accepts mutable inputs.
+ *
+ * Remove this file once the frontend ecosystem (e.g. @solana/client,
+ * @solana/react-hooks) publishes kit@6-compatible releases.
+ */
+type GetProgramAccountsRpc = {
+    getProgramAccounts(program: Parameters<Rpc<GetProgramAccountsApi>['getProgramAccounts']>[0], config?: Omit<NonNullable<Parameters<Rpc<GetProgramAccountsApi>['getProgramAccounts']>[1]>, 'filters'> & {
+        filters?: ProgramAccountsFilter[];
+    }): {
+        send(): Promise<unknown>;
+    };
+};
+
+/**
+ * Position fetching and utility functions for the CPMM SDK
+ */
+
+/**
+ * Configuration for fetching positions
+ */
+interface FetchPositionsConfig {
+    /** Program ID (defaults to CPMM program) */
+    programId?: Address;
+    /** Commitment level */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+/**
+ * Position with its address
+ */
+interface PositionWithAddress {
+    address: Address;
+    account: Position;
+}
+/**
+ * Position value in underlying tokens
+ */
+interface PositionValue {
+    /** Amount of token0 the position is worth */
+    amount0: bigint;
+    /** Amount of token1 the position is worth */
+    amount1: bigint;
+    /** Pending uncollected fees in token0 */
+    pendingFees0: bigint;
+    /** Pending uncollected fees in token1 */
+    pendingFees1: bigint;
+    /** Total value in token0 (amount0 + pending0) */
+    totalValue0: bigint;
+    /** Total value in token1 (amount1 + pending1) */
+    totalValue1: bigint;
+    /** Share of pool as a decimal (0-1) */
+    poolShare: number;
+}
+/**
+ * Fetch and decode a single position account
+ *
+ * @param rpc - Solana RPC client
+ * @param address - Position account address
+ * @param config - Optional configuration
+ * @returns Decoded position data or null if not found
+ *
+ * @example
+ * ```ts
+ * const position = await fetchPosition(rpc, positionAddress);
+ * if (position) {
+ *   console.log(`Position shares: ${position.shares}`);
+ * }
+ * ```
+ */
+declare function fetchPosition(rpc: Rpc<GetAccountInfoApi>, address: Address, config?: FetchPositionsConfig): Promise<Position | null>;
+/**
+ * Fetch all positions for a specific owner
+ *
+ * @param rpc - Solana RPC client
+ * @param owner - Owner address
+ * @param pool - Optional pool address to filter by
+ * @param config - Optional configuration
+ * @returns Array of positions with their addresses
+ *
+ * @example
+ * ```ts
+ * // Get all positions for a user
+ * const allPositions = await fetchUserPositions(rpc, userWallet);
+ *
+ * // Get positions for a specific pool
+ * const poolPositions = await fetchUserPositions(rpc, userWallet, poolAddress);
+ * ```
+ */
+declare function fetchUserPositions(rpc: GetProgramAccountsRpc, owner: Address, pool?: Address, config?: FetchPositionsConfig): Promise<PositionWithAddress[]>;
+/**
+ * Fetch all positions for a specific pool
+ *
+ * @param rpc - Solana RPC client
+ * @param pool - Pool address
+ * @param config - Optional configuration
+ * @returns Array of positions with their addresses
+ */
+declare function fetchPoolPositions(rpc: GetProgramAccountsRpc, pool: Address, config?: FetchPositionsConfig): Promise<PositionWithAddress[]>;
+/**
+ * Calculate the value of a position in underlying tokens
+ *
+ * @param pool - Pool data
+ * @param position - Position data
+ * @returns Position value breakdown
+ *
+ * @example
+ * ```ts
+ * const pool = await fetchPool(rpc, poolAddress);
+ * const position = await fetchPosition(rpc, positionAddress);
+ *
+ * if (pool && position) {
+ *   const value = getPositionValue(pool, position);
+ *   console.log(`Position worth ${value.amount0} token0 + ${value.amount1} token1`);
+ *   console.log(`Pool share: ${(value.poolShare * 100).toFixed(2)}%`);
+ * }
+ * ```
+ */
+declare function getPositionValue(pool: Pool, position: Position): PositionValue;
+/**
+ * Derive and fetch a position by its deterministic parameters
+ *
+ * @param rpc - Solana RPC client
+ * @param pool - Pool address
+ * @param owner - Position owner
+ * @param positionId - Position ID
+ * @param config - Optional configuration
+ * @returns Position with address or null if not found
+ */
+declare function fetchPositionByParams(rpc: Rpc<GetAccountInfoApi>, pool: Address, owner: Address, positionId: bigint, config?: FetchPositionsConfig): Promise<PositionWithAddress | null>;
+/**
+ * Get the position address for given parameters without fetching
+ *
+ * @param pool - Pool address
+ * @param owner - Position owner
+ * @param positionId - Position ID
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Position address
+ */
+declare function getPositionAddressFromParams(pool: Address, owner: Address, positionId: bigint, programId?: Address): Promise<Address>;
+/**
+ * Batch fetch multiple positions
+ *
+ * @param rpc - Solana RPC client
+ * @param addresses - Array of position addresses to fetch
+ * @param config - Optional configuration
+ * @returns Map of address to position (missing positions are not included)
+ */
+declare function fetchPositionsBatch(rpc: Rpc<GetAccountInfoApi>, addresses: Address[], config?: FetchPositionsConfig): Promise<Map<Address, Position>>;
+/**
+ * Filter positions with non-zero shares
+ *
+ * @param positions - Array of positions to filter
+ * @returns Positions with shares > 0
+ */
+declare function filterActivePositions(positions: PositionWithAddress[]): PositionWithAddress[];
+/**
+ * Sort positions by share amount
+ *
+ * @param positions - Array of positions to sort
+ * @param descending - Sort descending (largest first) if true
+ * @returns Sorted array (does not mutate input)
+ */
+declare function sortPositionsByShares(positions: PositionWithAddress[], descending?: boolean): PositionWithAddress[];
+
+/**
+ * Oracle fetching and TWAP utility functions for the CPMM SDK
+ */
+
+/**
+ * Configuration for fetching oracles
+ */
+interface FetchOracleConfig {
+    /** Program ID (defaults to CPMM program) */
+    programId?: Address;
+    /** Commitment level */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+/**
+ * Oracle with its address
+ */
+interface OracleWithAddress {
+    address: Address;
+    account: OracleState;
+}
+/**
+ * Fetch and decode an oracle state account
+ *
+ * @param rpc - Solana RPC client
+ * @param address - Oracle account address
+ * @param config - Optional configuration
+ * @returns Decoded oracle state or null if not found
+ *
+ * @example
+ * ```ts
+ * const oracle = await fetchOracle(rpc, oracleAddress);
+ * if (oracle) {
+ *   console.log(`Oracle initialized: ${oracle.initialized}`);
+ *   console.log(`Last update: ${oracle.lastTimestamp}`);
+ * }
+ * ```
+ */
+declare function fetchOracle(rpc: Rpc<GetAccountInfoApi>, address: Address, config?: FetchOracleConfig): Promise<OracleState | null>;
+/**
+ * Get the oracle for a specific pool
+ *
+ * Derives the oracle PDA from the pool address and fetches it.
+ *
+ * @param rpc - Solana RPC client
+ * @param pool - Pool address
+ * @param config - Optional configuration
+ * @returns Oracle data with address, or null if not found/initialized
+ *
+ * @example
+ * ```ts
+ * const result = await getOracleForPool(rpc, poolAddress);
+ * if (result) {
+ *   console.log(`Oracle at ${result.address}`);
+ *   const twap = consultTwap(result.account, 300); // 5-minute TWAP
+ *   console.log(`TWAP price: ${twap.price0}`);
+ * }
+ * ```
+ */
+declare function getOracleForPool(rpc: Rpc<GetAccountInfoApi>, pool: Address, config?: FetchOracleConfig): Promise<OracleWithAddress | null>;
+/**
+ * Get the oracle address for a pool without fetching
+ *
+ * @param pool - Pool address
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Oracle address
+ */
+declare function getOracleAddressFromPool(pool: Address, programId?: Address): Promise<Address>;
+/**
+ * Calculate TWAP price from oracle observations
+ *
+ * Finds the appropriate observations in the circular buffer and computes
+ * the time-weighted average price over the specified window.
+ *
+ * @param oracle - Oracle state data
+ * @param windowSeconds - TWAP window in seconds
+ * @param currentTimestamp - Optional override for current time (seconds)
+ * @returns TWAP prices for both directions, or null if insufficient data
+ *
+ * @example
+ * ```ts
+ * const oracle = await fetchOracle(rpc, oracleAddress);
+ * if (oracle && oracle.initialized) {
+ *   // Get 5-minute TWAP
+ *   const twap = consultTwap(oracle, 300);
+ *   if (twap) {
+ *     console.log(`Token0 price: ${twap.price0} token1 per token0`);
+ *     console.log(`Token1 price: ${twap.price1} token0 per token1`);
+ *   }
+ * }
+ * ```
+ */
+declare function consultTwap(oracle: OracleState, windowSeconds: number, currentTimestamp?: number): TwapResult | null;
+/**
+ * Get the current spot prices from oracle
+ *
+ * Uses the truncated (manipulation-resistant) prices stored in the oracle.
+ *
+ * @param oracle - Oracle state data
+ * @returns Current truncated prices
+ */
+declare function getOracleSpotPrices(oracle: OracleState): {
+    price0Q64: bigint;
+    price1Q64: bigint;
+    price0: number;
+    price1: number;
+};
+/**
+ * Get the price deviation metrics from oracle
+ *
+ * Deviation indicates how much the spot price has moved from the truncated price.
+ * High deviation may indicate price manipulation or rapid market movement.
+ *
+ * @param oracle - Oracle state data
+ * @returns Deviation values for both price directions
+ */
+declare function getOracleDeviation(oracle: OracleState): {
+    deviation0Q64: bigint;
+    deviation1Q64: bigint;
+    deviation0: number;
+    deviation1: number;
+};
+/**
+ * Calculate the age of the oracle (time since last update)
+ *
+ * @param oracle - Oracle state data
+ * @param currentTimestamp - Current timestamp (defaults to Date.now() / 1000)
+ * @returns Age in seconds
+ */
+declare function getOracleAge(oracle: OracleState, currentTimestamp?: number): number;
+/**
+ * Check if oracle is stale (hasn't been updated recently)
+ *
+ * @param oracle - Oracle state data
+ * @param maxAgeSeconds - Maximum acceptable age in seconds
+ * @param currentTimestamp - Current timestamp (defaults to Date.now() / 1000)
+ * @returns true if oracle is stale
+ */
+declare function isOracleStale(oracle: OracleState, maxAgeSeconds: number, currentTimestamp?: number): boolean;
+/**
+ * Get observation buffer statistics
+ *
+ * @param oracle - Oracle state data
+ * @returns Information about the observation buffer
+ */
+declare function getOracleBufferStats(oracle: OracleState): {
+    /** Total buffer capacity */
+    capacity: number;
+    /** Number of observations with data */
+    filledCount: number;
+    /** Current write index */
+    currentIndex: number;
+    /** Oldest observation timestamp (0 if not filled) */
+    oldestTimestamp: number;
+    /** Newest observation timestamp */
+    newestTimestamp: number;
+    /** Time span covered by observations */
+    timeSpanSeconds: number;
+};
+/**
+ * Batch fetch oracles for multiple pools
+ *
+ * @param rpc - Solana RPC client
+ * @param pools - Array of pool addresses
+ * @param config - Optional configuration
+ * @returns Map of pool address to oracle (missing oracles not included)
+ */
+declare function fetchOraclesBatch(rpc: Rpc<GetAccountInfoApi>, pools: Address[], config?: FetchOracleConfig): Promise<Map<Address, OracleWithAddress>>;
+/**
+ * Calculate price from pool reserves and compare with oracle
+ *
+ * Useful for detecting price discrepancies or manipulation.
+ *
+ * @param pool - Pool data
+ * @param oracle - Oracle data
+ * @returns Comparison metrics
+ */
+declare function comparePoolAndOraclePrices(pool: Pool, oracle: OracleState): {
+    /** Spot price from pool reserves (token1 per token0) */
+    poolPrice0: number;
+    /** Truncated price from oracle (token1 per token0) */
+    oraclePrice0: number;
+    /** Difference as percentage (positive = pool > oracle) */
+    divergencePct: number;
+};
+
+export { fetchPoolPositions as $, type AmmConfig as A, type PositionCreatedEvent as B, type CurveParams as C, type PositionClosedEvent as D, type SentinelInvokedEvent as E, type SentinelErrorEvent as F, type GetProgramAccountsRpc as G, type SentinelUpdatedEvent as H, type InitializeConfigArgs as I, type FeesUpdatedEvent as J, type OracleInitializedEvent as K, type OracleUpdatedEvent as L, type MarketCapValidationResult as M, type RouteUpdatedEvent as N, type OracleState as O, type Pool as P, type QuoteToNumeraireArgs as Q, type RemoveLiquidityQuote as R, type SwapDirection as S, type TransferAdminArgs as T, type AdminTransferredEvent as U, type PausedEvent as V, type UnpausedEvent as W, type SkimmedEvent as X, fetchPosition as Y, fetchUserPositions as Z, getPositionValue as _, type Position as a, fetchPositionByParams as a0, fetchPositionsBatch as a1, fetchOracle as a2, getOracleForPool as a3, consultTwap as a4, getOracleSpotPrices as a5, getOracleDeviation as a6, isOracleStale as a7, getOracleBufferStats as a8, type PositionValue as a9, type FetchPositionsConfig as aa, type PositionWithAddress as ab, type FetchOracleConfig as ac, type OracleWithAddress as ad, getPositionAddressFromParams as ae, filterActivePositions as af, sortPositionsByShares as ag, getOracleAddressFromPool as ah, getOracleAge as ai, fetchOraclesBatch as aj, comparePoolAndOraclePrices as ak, type SwapQuote as b, type SwapQuoteExactOut as c, type AddLiquidityQuote as d, type MarketCapToCurveParamsInput as e, type CurveParamsToMarketCapInput as f, type InitializePoolArgs as g, type InitializeOracleArgs as h, type SetFeesArgs as i, type SetSentinelArgs as j, type SetRouteArgs as k, type SwapExactInArgs as l, type CreatePositionArgs as m, type AddLiquidityArgs as n, type RemoveLiquidityArgs as o, type CollectFeesArgs as p, type CollectProtocolFeesArgs as q, type OracleConsultArgs as r, type Observation as s, type TwapResult as t, type SwapEvent as u, type AddLiquidityEvent as v, type RemoveLiquidityEvent as w, type CollectFeesEvent as x, type CollectProtocolFeesEvent as y, type PoolInitializedEvent as z };