@panoptic-eng/sdk 1.0.21 → 1.0.23

package/dist/types-CspUPolV.d.ts

@@ -0,0 +1,892 @@
+import { BlockMeta } from "./simulation-4SzTI-xf.js";
+import { TxOverrides } from "./tx-Banz1S18.js";
+import { Address, PublicClient, WalletClient } from "viem";
+
+//#region src/panoptic/v2/formatters/tick.d.ts
+/**
+* Tick and price formatters for Uniswap V3/V4 pools.
+*
+* Ticks represent logarithmic prices where: price = 1.0001^tick
+*
+* @module v2/formatters/tick
+*/
+/**
+ * Tick and price formatters for Uniswap V3/V4 pools.
+ *
+ * Ticks represent logarithmic prices where: price = 1.0001^tick
+ *
+ * @module v2/formatters/tick
+ */
+declare function tickToSqrtPriceX96(tick: bigint): bigint;
+/**
+ * Convert a tick to a raw price string (no decimal adjustment).
+ * Uses the formula: price = 1.0001^tick
+ *
+ * This returns the raw price ratio, not adjusted for token decimals.
+ * A fixed internal precision is used and trailing zeros are trimmed.
+ *
+ * @param tick - The tick value
+ * @returns Price string
+ *
+ * @example
+ * ```typescript
+ * tickToPrice(0n)       // "1"
+ * tickToPrice(1000n)    // "1.105..." (approximately)
+ * tickToPrice(-1000n)   // "0.904..." (approximately)
+ * tickToPrice(200000n)  // Very large number
+ * ```
+ */
+declare function tickToPrice(tick: bigint): string;
+/**
+ * Convert a tick to a human-readable price with decimal scaling.
+ * Uses the formula: price = 1.0001^tick * 10^(decimals0-decimals1)
+ *
+ * This adjusts for the different decimals of the two tokens in the pair.
+ *
+ * @param tick - The tick value
+ * @param decimals0 - Decimals of token0
+ * @param decimals1 - Decimals of token1
+ * @param precision - Number of decimal places to display
+ * @returns Formatted price string
+ *
+ * @example
+ * ```typescript
+ * // WETH/USDC pool (18 decimals / 6 decimals)
+ * // At tick ~200000, price is roughly $2000 per ETH
+ * tickToPriceDecimalScaled(200000n, 18n, 6n, 2n) // "2000.00" (approximately)
+ *
+ * // For token1/token0 price, swap the decimals
+ * tickToPriceDecimalScaled(200000n, 6n, 18n, 6n) // "0.000500" (approximately)
+ * ```
+ */
+declare function tickToPriceDecimalScaled(tick: bigint, decimals0: bigint, decimals1: bigint, precision: bigint): string;
+/**
+ * Convert a sqrtPriceX96 to a human-readable price with decimal scaling.
+ *
+ * Uses the formula: price = (sqrtPriceX96^2 / 2^192) * 10^(decimals0-decimals1)
+ *
+ * @param sqrtPriceX96 - The sqrt price in Q64.96 format
+ * @param decimals0 - Decimals of token0
+ * @param decimals1 - Decimals of token1
+ * @param precision - Number of decimal places to display
+ * @returns Formatted price string
+ *
+ * @example
+ * ```typescript
+ * sqrtPriceX96ToPriceDecimalScaled(2n ** 96n, 18n, 18n, 2n) // "1.00"
+ * ```
+ */
+declare function sqrtPriceX96ToPriceDecimalScaled(sqrtPriceX96: bigint, decimals0: bigint, decimals1: bigint, precision: bigint): string;
+/**
+ * Convert a price to a tick value.
+ *
+ * @param price - The price string
+ * @param decimals0 - Decimals of token0
+ * @param decimals1 - Decimals of token1
+ * @returns The tick value (rounded to nearest integer)
+ *
+ * @example
+ * ```typescript
+ * // WETH/USDC: What tick for $2000 per ETH?
+ * priceToTick("2000", 18n, 6n) // ~200000n
+ *
+ * // Inverse: What tick for 0.0005 ETH per USDC?
+ * priceToTick("0.0005", 6n, 18n) // ~200000n
+ * ```
+ */
+declare function priceToTick(price: string, decimals0: bigint, decimals1: bigint): bigint;
+/**
+ * Convert a sqrtPriceX96 value to the nearest tick.
+ *
+ * @param sqrtPriceX96 - The sqrt price in Q64.96 format
+ * @returns The tick value (rounded to nearest integer)
+ *
+ * @example
+ * ```typescript
+ * const tick = sqrtPriceX96ToTick(2n ** 96n) // 0n
+ * ```
+ */
+declare function sqrtPriceX96ToTick(sqrtPriceX96: bigint): bigint;
+/**
+ * Format a tick value for display.
+ *
+ * @param tick - The tick value
+ * @returns Formatted tick string
+ *
+ * @example
+ * ```typescript
+ * formatTick(200000n)  // "200000"
+ * formatTick(-50000n)  // "-50000"
+ * ```
+ */
+declare function formatTick(tick: bigint): string;
+/**
+ * Get the price at a specific tick, returning both token0/token1 and token1/token0 prices.
+ *
+ * @param tick - The tick value
+ * @param decimals0 - Decimals of token0
+ * @param decimals1 - Decimals of token1
+ * @param precision - Number of decimal places to display
+ * @returns Object with both price directions
+ *
+ * @example
+ * ```typescript
+ * const prices = getPricesAtTick(200000n, 18n, 6n, 2n)
+ * // prices.token0PerToken1 = "0.00" (very small)
+ * // prices.token1PerToken0 = "2000.00" (USDC per ETH)
+ * ```
+ */
+declare function getPricesAtTick(tick: bigint, decimals0: bigint, decimals1: bigint, precision: bigint): {
+  token0PerToken1: string;
+  token1PerToken0: string;
+};
+/**
+ * Format a tick range for display.
+ *
+ * @param tickLower - Lower tick
+ * @param tickUpper - Upper tick
+ * @returns Formatted tick range string
+ *
+ * @example
+ * ```typescript
+ * formatTickRange(-50000n, 200000n) // "-50000 - 200000"
+ * ```
+ */
+declare function formatTickRange(tickLower: bigint, tickUpper: bigint): string;
+/**
+ * Format a price range for display.
+ *
+ * @param tickLower - Lower tick
+ * @param tickUpper - Upper tick
+ * @param decimals0 - Decimals of token0
+ * @param decimals1 - Decimals of token1
+ * @param precision - Number of decimal places to display
+ * @returns Formatted price range string
+ *
+ * @example
+ * ```typescript
+ * formatPriceRange(0n, 0n, 18n, 18n, 2n) // "1.00 - 1.00"
+ * ```
+ */
+declare function formatPriceRange(tickLower: bigint, tickUpper: bigint, decimals0: bigint, decimals1: bigint, precision: bigint): string;
+/**
+ * Calculate the tick spacing for a given fee tier.
+ *
+ * @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
+ * @returns Tick spacing
+ *
+ * @example
+ * ```typescript
+ * getTickSpacing(100n)  // 1n (0.01% fee tier)
+ * getTickSpacing(500n)  // 10n (0.05% fee tier)
+ * getTickSpacing(3000n) // 60n (0.30% fee tier)
+ * getTickSpacing(10000n) // 200n (1.00% fee tier)
+ * ```
+ */
+declare function getTickSpacing(feeBps: bigint): bigint;
+/**
+ * Round a tick to the nearest valid tick for a given tick spacing.
+ *
+ * @param tick - The tick to round
+ * @param tickSpacing - The tick spacing
+ * @returns Rounded tick
+ *
+ * @example
+ * ```typescript
+ * roundToTickSpacing(12345n, 10n) // 12340n
+ * roundToTickSpacing(12345n, 60n) // 12360n
+ * roundToTickSpacing(-12345n, 10n) // -12350n
+ * ```
+ */
+declare function roundToTickSpacing(tick: bigint, tickSpacing: bigint): bigint;
+/**
+ * Result of {@link tickLimits}.
+ */
+interface TickLimitsResult {
+  /** Lower tick limit (clamped to MIN_TICK). */
+  low: bigint;
+  /** Upper tick limit (clamped to MAX_TICK). */
+  high: bigint;
+}
+/**
+ * Compute slippage-bounded tick limits around the current tick.
+ *
+ * 1 tick ≈ 1 basis point (0.01 %) of price change, so a `toleranceBps`
+ * of 500 allows roughly 5 % price movement.  The result is clamped to
+ * the protocol's `[MIN_TICK, MAX_TICK]` range.
+ *
+ * Useful for setting `tickLimitLow` / `tickLimitHigh` on `openPosition`
+ * and `closePosition` to protect against MEV sandwiches and volatile
+ * tick moves.
+ *
+ * @param currentTick - The current pool tick (must be within [MIN_TICK, MAX_TICK]).
+ * @param toleranceBps - Slippage tolerance in basis points (≈ ticks). Must be non-negative.
+ * @returns Clamped `{ low, high }` tick limits.
+ * @throws {RangeError} If `toleranceBps` is negative or `currentTick` is out of bounds.
+ *
+ * @example
+ * ```typescript
+ * const { low, high } = tickLimits(200_000n, 500n)
+ * // low  = 199_500n
+ * // high = 200_500n
+ *
+ * await openPosition({ ..., tickLimitLow: low, tickLimitHigh: high })
+ * ```
+ */
+declare function tickLimits(currentTick: bigint, toleranceBps: bigint): TickLimitsResult; //#endregion
+//#region src/panoptic/v2/reads/pool.d.ts
+/**
+ * Immutable pool metadata that can be cached.
+ * These values never change for a given pool, so they're exempt from
+ * same-block consistency requirements (per PLAN.md "Static Prefetches" exception).
+ */
+interface PoolMetadata {
+  /** Pool key bytes */
+  poolKeyBytes: `0x${string}`;
+  /** Pool ID */
+  poolId: bigint;
+  /** Collateral tracker 0 address */
+  collateralToken0Address: Address;
+  /** Collateral tracker 1 address */
+  collateralToken1Address: Address;
+  /** Risk engine address */
+  riskEngineAddress: Address;
+  /** Token 0 underlying asset address */
+  token0Asset: Address;
+  /** Token 1 underlying asset address */
+  token1Asset: Address;
+  /** Token 0 symbol */
+  token0Symbol: string;
+  /** Token 1 symbol */
+  token1Symbol: string;
+  /** Token 0 decimals */
+  token0Decimals: bigint;
+  /** Token 1 decimals */
+  token1Decimals: bigint;
+  /** Token 0 name */
+  token0Name: string;
+  /** Token 1 name */
+  token1Name: string;
+  /** Underlying pool ID (V3: pool address, V4: keccak256(poolKeyBytes)) */
+  underlyingPoolId: string;
+  /** Whether this is a V4 pool (poolManager is non-zero) */
+  isV4: boolean;
+  /** Tick spacing */
+  tickSpacing: bigint;
+  /** Fee tier (V4: from poolKey, V3: from Uniswap pool fee()) */
+  fee: bigint;
+  /** SemiFungiblePositionManager address */
+  sfpmAddress: Address;
+}
+/**
+ * Parameters for getPoolMetadata.
+ */
+interface GetPoolMetadataParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+}
+/**
+ * Fetch immutable pool metadata (addresses, symbols, decimals).
+ * This data never changes for a given pool and can be cached indefinitely.
+ *
+ * This is the "static prefetch" per PLAN.md §6 - exempt from same-block consistency.
+ *
+ * @param params - The parameters
+ * @returns Immutable pool metadata
+ */
+declare function getPoolMetadata(params: GetPoolMetadataParams): Promise<PoolMetadata>;
+/**
+ * Parameters for getPool.
+ */
+interface GetPoolParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+  /** Chain ID */
+  chainId: bigint;
+  /** Optional block number for historical queries */
+  blockNumber?: bigint;
+  /** Optional pre-fetched pool metadata (for caching/optimization) */
+  poolMetadata?: PoolMetadata;
+  /** Optional StateView address for V4 pools (needed to read Uniswap pool liquidity) */
+  stateViewAddress?: Address;
+  /** Optional pre-fetched block metadata (skips getBlockMeta RPC call) */
+  _meta?: BlockMeta;
+}
+/**
+ * Get full pool data including both collateral trackers and oracle state.
+ *
+ * ## Same-Block Guarantee
+ * All dynamic data is fetched in ONE multicall at the target block.
+ * Static metadata (addresses, symbols, decimals) is either provided via
+ * poolMetadata or fetched separately (static prefetch exception).
+ *
+ * @param params - The parameters
+ * @returns Pool data with block metadata
+ */
+declare function getPool(params: GetPoolParams): Promise<Pool>;
+/**
+ * Parameters for getUtilization.
+ */
+interface GetUtilizationParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+  /** Optional block number for historical queries */
+  blockNumber?: bigint;
+  /** Optional pre-fetched collateral tracker addresses (for caching/optimization) */
+  collateralAddresses?: {
+    collateralToken0: Address;
+    collateralToken1: Address;
+  };
+  /** Optional pre-fetched block metadata (skips getBlockMeta RPC call) */
+  _meta?: BlockMeta;
+}
+/**
+ * Get current pool utilization for both tokens.
+ *
+ * ## Same-Block Guarantee
+ * All dynamic data is fetched in ONE multicall at the target block.
+ * Collateral tracker addresses are either provided or fetched separately (static prefetch).
+ *
+ * @param params - The parameters
+ * @returns Utilization data with block metadata
+ */
+declare function getUtilization(params: GetUtilizationParams): Promise<Utilization>;
+/**
+ * Parameters for getOracleState.
+ */
+interface GetOracleStateParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+  /** Optional block number for historical queries */
+  blockNumber?: bigint;
+  /** Optional pre-fetched block metadata (skips getBlockMeta RPC call) */
+  _meta?: BlockMeta;
+}
+/**
+ * Get current oracle state from the pool.
+ *
+ * ## Same-Block Guarantee
+ * Single contract call + block meta fetch at the same block.
+ *
+ * @param params - The parameters
+ * @returns Oracle state with block metadata
+ */
+declare function getOracleState(params: GetOracleStateParams): Promise<OracleState>;
+/**
+ * Parameters for getRiskParameters.
+ */
+interface GetRiskParametersParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+  /** Builder code (default: 0) */
+  builderCode?: bigint;
+  /** Optional block number for historical queries */
+  blockNumber?: bigint;
+  /** Optional pre-fetched risk engine address (for caching/optimization) */
+  riskEngineAddress?: Address;
+  /** Optional pre-fetched block metadata (skips getBlockMeta RPC call) */
+  _meta?: BlockMeta;
+}
+/**
+ * Get risk parameters from the pool.
+ *
+ * ## Same-Block Guarantee
+ * All dynamic data is fetched in ONE multicall at the target block.
+ * Risk engine address is either provided or fetched separately (static prefetch).
+ *
+ * @param params - The parameters
+ * @returns Risk parameters with block metadata
+ */
+declare function getRiskParameters(params: GetRiskParametersParams): Promise<RiskParameters>;
+/**
+ * Validate whether a builder code maps to a deployed builder wallet.
+ *
+ * Calls `PanopticPool.getRiskParameters(builderCode)` — the contract reverts
+ * with `InvalidBuilderCode` when the computed CREATE2 address has no bytecode.
+ *
+ * @returns `true` when valid, `false` when the contract reverts.
+ */
+declare function validateBuilderCode(params: {
+  client: PublicClient;
+  poolAddress: Address;
+  builderCode: bigint;
+}): Promise<boolean>;
+/**
+ * Parameters for fetchPoolId.
+ */
+interface FetchPoolIdParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address;
+}
+/**
+ * Result of fetchPoolId, including block metadata for same-block consistency.
+ */
+interface FetchPoolIdResult {
+  /** The encoded 64-bit pool ID */
+  poolId: bigint;
+  /** Block metadata from the pinned read */
+  _meta: BlockMeta;
+}
+/**
+ * Fetch the encoded 64-bit pool ID from a PanopticPool contract.
+ *
+ * Use this when you need the poolId without fetching the full pool state.
+ * The returned poolId can be passed directly to `createTokenIdBuilder()`.
+ * The read is pinned to the latest block at call time.
+ *
+ * @param params - The parameters
+ * @returns The pool ID and block metadata
+ */
+declare function fetchPoolId(params: FetchPoolIdParams): Promise<FetchPoolIdResult>;
+
+//#endregion
+//#region src/panoptic/v2/types/pool.d.ts
+/**
+ * Pool health status.
+ */
+type PoolHealthStatus = 'active' | 'low_liquidity' | 'paused';
+/**
+ * Collateral tracker information.
+ */
+interface CollateralTracker {
+  /** Address of the collateral tracker contract */
+  address: Address;
+  /** Address of the underlying token */
+  token: Address;
+  /** Token symbol */
+  symbol: string;
+  /** Token decimals */
+  decimals: bigint;
+  /** Total assets accounted to the pool (deposited assets plus assets in the AMM) */
+  totalAssets: bigint;
+  /** Assets currently inside the AMM (deployed as liquidity) */
+  insideAMM: bigint;
+  /** Credited shares (shares owed to liquidity providers) */
+  creditedShares: bigint;
+  /** Total shares outstanding */
+  totalShares: bigint;
+  /** Current utilization (0-10000 bps) */
+  utilization: bigint;
+  /** Current borrow rate (annualized, WAD-scaled: 1e18 = 100%/year) */
+  borrowRate: bigint;
+  /** Current supply rate (annualized, WAD-scaled: 1e18 = 100%/year) */
+  supplyRate: bigint;
+}
+/**
+ * Risk engine information.
+ */
+interface RiskEngine {
+  /** Address of the risk engine contract */
+  address: Address;
+  /** Collateral requirement factor (in bps) */
+  collateralRequirement: bigint;
+  /** Maintenance margin factor (in bps) */
+  maintenanceMargin: bigint;
+  /** Commission rate (in bps) */
+  commissionRate: bigint;
+  /** VEGOID constant used in spread calculation */
+  vegoid: bigint;
+  /** Maximum spread parameter (in bps) */
+  maxSpread: bigint;
+}
+/**
+ * Uniswap V4 pool key.
+ */
+interface PoolKey {
+  /** Token 0 address */
+  currency0: Address;
+  /** Token 1 address */
+  currency1: Address;
+  /** Fee tier */
+  fee: bigint;
+  /** Tick spacing */
+  tickSpacing: bigint;
+  /** Hook address (if any) */
+  hooks: Address;
+}
+/**
+ * Pool data returned by getPool().
+ */
+interface Pool {
+  /** Address of the PanopticPool contract */
+  address: Address;
+  /** Chain ID */
+  chainId: bigint;
+  /** Encoded pool ID (64-bit) */
+  poolId: bigint;
+  /** Uniswap pool key (V4: full struct, V3: zeroed fields) */
+  poolKey: PoolKey;
+  /** Tick spacing (extracted from encoded poolId) */
+  tickSpacing: bigint;
+  /** Token 0 collateral tracker */
+  collateralTracker0: CollateralTracker;
+  /** Token 1 collateral tracker */
+  collateralTracker1: CollateralTracker;
+  /** Risk engine */
+  riskEngine: RiskEngine;
+  /** Current tick */
+  currentTick: bigint;
+  /** Current sqrt price (Q64.96) */
+  sqrtPriceX96: bigint;
+  /** Uniswap pool in-range liquidity (from V3 pool.liquidity() or V4 StateView.getLiquidity()) */
+  uniswapPoolLiquidity: bigint;
+  /** Pool health status */
+  healthStatus: PoolHealthStatus;
+  /** Immutable pool metadata (addresses, symbols, decimals, names, underlyingPoolId) */
+  metadata: PoolMetadata;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Utilization data for both tokens.
+ */
+interface Utilization {
+  /** Token 0 utilization (0-10000 bps) */
+  utilization0: bigint;
+  /** Token 1 utilization (0-10000 bps) */
+  utilization1: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/oracle.d.ts
+/**
+ * Safe mode level from the RiskEngine.
+ */
+type SafeMode = 'normal' | 'restricted' | 'emergency';
+/**
+ * Oracle state from the PanopticPool.
+ */
+interface OracleState {
+  /** Last update epoch (64-second intervals) */
+  epoch: bigint;
+  /** Last update timestamp */
+  lastUpdateTimestamp: bigint;
+  /** Reference tick */
+  referenceTick: bigint;
+  /** Spot EMA tick */
+  spotEMA: bigint;
+  /** Fast EMA tick */
+  fastEMA: bigint;
+  /** Slow EMA tick */
+  slowEMA: bigint;
+  /** Eons EMA tick */
+  eonsEMA: bigint;
+  /** Lock mode (0 = unlocked, 1 = spot locked, 2 = full locked) */
+  lockMode: bigint;
+  /** Median tick from sorted observations */
+  medianTick: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Safe mode state from the RiskEngine.
+ */
+interface SafeModeState {
+  /** Current safe mode level */
+  mode: SafeMode;
+  /** Whether minting new positions is allowed */
+  canMint: boolean;
+  /** Whether burning positions is allowed */
+  canBurn: boolean;
+  /** Whether force exercise is allowed */
+  canForceExercise: boolean;
+  /** Whether liquidations are allowed */
+  canLiquidate: boolean;
+  /** Whether swapAtMint is allowed (false for NO_SWAP level 2+) */
+  canSwapAtMint: boolean;
+  /** Reason for current safe mode (if not normal) */
+  reason?: string;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Risk parameters from the RiskEngine.
+ */
+interface RiskParameters {
+  /** Collateral requirement multiplier (in bps, e.g., 10000 = 100%) */
+  collateralRequirement: bigint;
+  /** Maintenance margin requirement (in bps) */
+  maintenanceMargin: bigint;
+  /** Commission rate (in bps) */
+  commissionRate: bigint;
+  /** Target pool utilization (in bps) */
+  targetUtilization: bigint;
+  /** Saturated pool utilization threshold (in bps) */
+  saturatedUtilization: bigint;
+  /** ITM spread multiplier */
+  itmSpreadMultiplier: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Current interest rates from the CollateralTrackers.
+ */
+interface CurrentRates {
+  /** Token 0 borrow rate (per-second, WAD-scaled) */
+  borrowRate0: bigint;
+  /** Token 0 supply rate (per-second, WAD-scaled) */
+  supplyRate0: bigint;
+  /** Token 1 borrow rate (per-second, WAD-scaled) */
+  borrowRate1: bigint;
+  /** Token 1 supply rate (per-second, WAD-scaled) */
+  supplyRate1: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+
+//#endregion
+//#region src/uniswap/v4/addresses.d.ts
+/**
+ * Uniswap v4 contract addresses required for a Universal Router spot swap.
+ */
+interface UniswapV4Addresses {
+  /** Universal Router (v4-capable build) — entrypoint for `execute(...)`. */
+  universalRouter: Address;
+  /** V4Quoter — `quoteExactInputSingle` (revert/staticcall-based). */
+  v4Quoter: Address;
+  /** Uniswap v4 PoolManager (singleton). */
+  poolManager: Address;
+  /** Canonical Permit2 (same address on every chain). */
+  permit2: Address;
+}
+/**
+ * Canonical Permit2, identical across all chains.
+ */
+declare const PERMIT2_ADDRESS: Address;
+/**
+ * Verified Uniswap v4 deployment addresses keyed by chainId.
+ *
+ * Sourced from the official Uniswap v4 deployments. Add a chain here only after
+ * verifying each address against the canonical Uniswap deployment listing —
+ * Universal Router in particular is NOT the same address across chains.
+ */
+declare const UNISWAP_V4_ADDRESSES: Record<number, UniswapV4Addresses>;
+/**
+ * Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
+ *
+ * @param chainId - Target chain ID.
+ * @param overrides - Partial override of any address (e.g. for fork tests).
+ * @returns Fully-resolved {@link UniswapV4Addresses}.
+ * @throws {UnsupportedChainError} when the chain is not listed and the
+ *   overrides do not supply every required address.
+ */
+declare function getUniswapV4Addresses(chainId: bigint, overrides?: Partial<UniswapV4Addresses>): UniswapV4Addresses;
+
+//#endregion
+//#region src/uniswap/v4/router/types.d.ts
+/**
+ * Parameters for {@link swapExactInViaRouter}.
+ */
+interface SwapExactInViaRouterParams {
+  /** Public client for reads + receipts. */
+  client: PublicClient;
+  /** Wallet client for signing. */
+  walletClient: WalletClient;
+  /** Account address. */
+  account: Address;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID (selects per-chain Uniswap v4 addresses). */
+  chainId: bigint;
+  /** Token to sell. `address(0)` (zero address) for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of `tokenIn` to spend (must fit uint128). */
+  amountIn: bigint;
+  /** Slippage tolerance in bps (e.g. 500n = 5%). */
+  slippageBps: bigint;
+  /** Absolute deadline (unix seconds). If omitted, derived from block timestamp. */
+  deadline?: bigint;
+  /** Recipient of the output. Defaults to `account`. */
+  recipient?: Address;
+  /** Gas and transaction overrides. */
+  txOverrides?: TxOverrides;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link quoteSwapExactInViaRouter}.
+ */
+interface QuoteSwapExactInViaRouterParams {
+  /** Public client. */
+  client: PublicClient;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID. */
+  chainId: bigint;
+  /** Token to sell. `address(0)` for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of `tokenIn` to spend (must fit uint128). */
+  amountIn: bigint;
+  /** Slippage tolerance in bps (used to compute `amountOutMinimum`). */
+  slippageBps: bigint;
+  /** Optional block number for the quote. */
+  blockNumber?: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Quote result data (carried inside a `SimulationResult`).
+ */
+interface SwapExactInQuote {
+  /** Quoted output amount of `tokenOut`. */
+  amountOut: bigint;
+  /** Minimum acceptable output after applying slippage. */
+  amountOutMinimum: bigint;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
+  poolKey: PoolKey;
+  /** Quoter's gas estimate. */
+  gasEstimate: bigint;
+}
+/**
+ * Parameters for {@link swapExactOutViaRouter}.
+ */
+interface SwapExactOutViaRouterParams {
+  /** Public client for reads + receipts. */
+  client: PublicClient;
+  /** Wallet client for signing. */
+  walletClient: WalletClient;
+  /** Account address. */
+  account: Address;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID (selects per-chain Uniswap v4 addresses). */
+  chainId: bigint;
+  /** Token to sell (the pay token). `address(0)` (zero address) for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of the output token to receive (must fit uint128). */
+  amountOut: bigint;
+  /** Slippage tolerance in bps (e.g. 500n = 5%); caps the input. */
+  slippageBps: bigint;
+  /** Absolute deadline (unix seconds). If omitted, derived from block timestamp. */
+  deadline?: bigint;
+  /** Recipient of the output. Defaults to `account`. */
+  recipient?: Address;
+  /** Gas and transaction overrides. */
+  txOverrides?: TxOverrides;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link quoteSwapExactOutViaRouter}.
+ */
+interface QuoteSwapExactOutViaRouterParams {
+  /** Public client. */
+  client: PublicClient;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID. */
+  chainId: bigint;
+  /** Token to sell (the pay token). `address(0)` for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of the output token to receive (must fit uint128). */
+  amountOut: bigint;
+  /** Slippage tolerance in bps (used to compute `amountInMaximum`). */
+  slippageBps: bigint;
+  /** Optional block number for the quote. */
+  blockNumber?: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Quote result data for an exact-out swap (carried inside a `SimulationResult`).
+ */
+interface SwapExactOutQuote {
+  /** Quoted input amount of `tokenIn` required for the exact output. */
+  amountIn: bigint;
+  /** Maximum acceptable input after applying slippage. */
+  amountInMaximum: bigint;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
+  poolKey: PoolKey;
+  /** Quoter's gas estimate. */
+  gasEstimate: bigint;
+}
+/**
+ * Parameters for {@link checkRouterApproval}.
+ */
+interface CheckRouterApprovalParams {
+  /** Public client. */
+  client: PublicClient;
+  /** Chain ID. */
+  chainId: bigint;
+  /** ERC20 token being spent (must not be native ETH). */
+  tokenIn: Address;
+  /** Token owner. */
+  owner: Address;
+  /** Amount that must be spendable. */
+  amount: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Result of {@link checkRouterApproval}.
+ */
+interface RouterApprovalStatus {
+  /** ERC20 → Permit2 allowance is insufficient. */
+  needsErc20Approval: boolean;
+  /** Permit2 → Universal Router allowance is insufficient or expired. */
+  needsPermit2Approval: boolean;
+  /** Current ERC20 → Permit2 allowance. */
+  erc20Allowance: bigint;
+  /** Current Permit2 → router allowance amount. */
+  permit2Amount: bigint;
+  /** Current Permit2 → router allowance expiration (unix seconds). */
+  permit2Expiration: bigint;
+}
+/**
+ * Parameters for {@link approveErc20ForPermit2}.
+ */
+interface ApproveErc20ForPermit2Params {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  chainId: bigint;
+  /** ERC20 token to approve to Permit2. */
+  tokenIn: Address;
+  /** Amount to approve. Defaults to uint256 max. */
+  amount?: bigint;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link approveRouterViaPermit2}.
+ */
+interface ApproveRouterViaPermit2Params {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  chainId: bigint;
+  /** ERC20 token the router is allowed to spend via Permit2. */
+  tokenIn: Address;
+  /** Amount to approve (must fit uint160). Defaults to uint160 max. */
+  amount?: bigint;
+  /** Allowance expiration (unix seconds, uint48). If omitted, block timestamp + 30 days. */
+  expiration?: bigint;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV4Addresses>;
+}
+
+//#endregion
+export { ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, CheckRouterApprovalParams, CollateralTracker, CurrentRates, FetchPoolIdParams, FetchPoolIdResult, GetOracleStateParams, GetPoolMetadataParams, GetPoolParams, GetRiskParametersParams, GetUtilizationParams, OracleState, PERMIT2_ADDRESS as PERMIT2_ADDRESS$1, Pool, PoolHealthStatus, PoolKey, PoolMetadata, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, RiskEngine, RiskParameters, RouterApprovalStatus, SafeMode, SafeModeState, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, TickLimitsResult, UNISWAP_V4_ADDRESSES as UNISWAP_V4_ADDRESSES$1, UniswapV4Addresses, Utilization, fetchPoolId as fetchPoolId$1, formatPriceRange as formatPriceRange$1, formatTick as formatTick$1, formatTickRange as formatTickRange$1, getOracleState as getOracleState$1, getPool as getPool$1, getPoolMetadata as getPoolMetadata$1, getPricesAtTick as getPricesAtTick$1, getRiskParameters as getRiskParameters$1, getTickSpacing as getTickSpacing$1, getUniswapV4Addresses as getUniswapV4Addresses$1, getUtilization as getUtilization$1, priceToTick as priceToTick$1, roundToTickSpacing as roundToTickSpacing$1, sqrtPriceX96ToPriceDecimalScaled as sqrtPriceX96ToPriceDecimalScaled$1, sqrtPriceX96ToTick as sqrtPriceX96ToTick$1, tickLimits as tickLimits$1, tickToPrice as tickToPrice$1, tickToPriceDecimalScaled as tickToPriceDecimalScaled$1, tickToSqrtPriceX96 as tickToSqrtPriceX96$1, validateBuilderCode as validateBuilderCode$1 };
+//# sourceMappingURL=types-CspUPolV.d.ts.map