@panoptic-eng/sdk 1.0.5 → 1.0.6

package/dist/index-DVMjZi1E.d.ts

@@ -0,0 +1,1801 @@
+import { Address, Hash, PublicClient } from "viem";
+
+//#region src/panoptic/v2/types/meta.d.ts
+/**
+* Block metadata types for the Panoptic v2 SDK.
+* @module v2/types/meta
+*/
+/**
+* Block metadata attached to all RPC responses.
+* Used for freshness checks and reorg detection.
+*/
+/**
+ * Block metadata types for the Panoptic v2 SDK.
+ * @module v2/types/meta
+ */
+/**
+ * Block metadata attached to all RPC responses.
+ * Used for freshness checks and reorg detection.
+ */
+interface BlockMeta {
+  /** Block number when the data was fetched */
+  blockNumber: bigint;
+  /** Block timestamp in Unix seconds */
+  blockTimestamp: bigint;
+  /** Block hash for reorg detection */
+  blockHash: `0x${string}`;
+  /** Whether the data is considered stale */
+  isStale?: boolean;
+} //#endregion
+//#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
+ */
+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/position.d.ts
+/**
+ * A single leg of a TokenId.
+ */
+interface TokenIdLeg {
+  /** Leg index (0-3) */
+  index: bigint;
+  /** Asset index (0 or 1) */
+  asset: bigint;
+  /** Option ratio (1-127) */
+  optionRatio: bigint;
+  /** Whether this is a long position (true) or short (false) */
+  isLong: boolean;
+  /** Token type (0 or 1) - which token is being moved */
+  tokenType: bigint;
+  /** Risk partner leg index (for spreads) */
+  riskPartner: bigint;
+  /** Strike tick (center of the range) */
+  strike: bigint;
+  /** Width in tick spacing units */
+  width: bigint;
+  /** Lower tick of the range */
+  tickLower: bigint;
+  /** Upper tick of the range */
+  tickUpper: bigint;
+}
+/**
+ * Position data.
+ */
+interface Position {
+  /** The TokenId (256-bit identifier) */
+  tokenId: bigint;
+  /** Position size (number of contracts) */
+  positionSize: bigint;
+  /** Owner address */
+  owner: Address;
+  /** Pool address */
+  poolAddress: Address;
+  /** Decoded legs */
+  legs: TokenIdLeg[];
+  /** Pool utilization for token 0 at mint (0-10000 bps) */
+  poolUtilization0AtMint: bigint;
+  /** Pool utilization for token 1 at mint (0-10000 bps) */
+  poolUtilization1AtMint: bigint;
+  /** Tick at the time of minting */
+  tickAtMint: bigint;
+  /** Timestamp at the time of minting (Unix seconds) */
+  timestampAtMint: bigint;
+  /** Block number at the time of minting */
+  blockNumberAtMint: bigint;
+  /** Whether a swap occurred at mint */
+  swapAtMint: boolean;
+  /** Accumulated premia owed for token 0 */
+  premiaOwed0: bigint;
+  /** Accumulated premia owed for token 1 */
+  premiaOwed1: bigint;
+  /** Whether this is an optimistic pending position */
+  pending?: boolean;
+  /** Asset index used for greek calculations */
+  assetIndex: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Parameters for client-side leg greek calculations.
+ */
+interface LegGreeksParams {
+  /** The leg to calculate greeks for */
+  leg: TokenIdLeg;
+  /** Current tick */
+  tick: bigint;
+  /** Tick at mint (for value calculation) */
+  mintTick?: bigint;
+  /** Asset index (0 or 1) */
+  assetIndex: bigint;
+  /** Whether this is a defined risk position */
+  definedRisk: boolean;
+}
+/**
+ * Position greeks (value, delta, gamma).
+ */
+interface PositionGreeks {
+  /** Position value in numeraire token units */
+  value: bigint;
+  /** Position delta in numeraire token units */
+  delta: bigint;
+  /** Position gamma in numeraire token units */
+  gamma: bigint;
+}
+/**
+ * Closed position data for trade history.
+ */
+interface ClosedPosition {
+  /** The TokenId */
+  tokenId: bigint;
+  /** Owner address */
+  owner: Address;
+  /** Pool address */
+  poolAddress: Address;
+  /** Position size at close */
+  positionSize: bigint;
+  /** Open block number */
+  openBlock: bigint;
+  /** Close block number */
+  closeBlock: bigint;
+  /** Open timestamp */
+  openTimestamp: bigint;
+  /** Close timestamp */
+  closeTimestamp: bigint;
+  /** Tick at open */
+  tickAtOpen: bigint;
+  /** Tick at close */
+  tickAtClose: bigint;
+  /** Realized PnL for token 0 */
+  realizedPnL0: bigint;
+  /** Realized PnL for token 1 */
+  realizedPnL1: bigint;
+  /** Total premia collected for token 0 */
+  premiaCollected0: bigint;
+  /** Total premia collected for token 1 */
+  premiaCollected1: bigint;
+  /** Closure reason */
+  closureReason: 'closed' | 'liquidated' | 'force_exercised';
+}
+/**
+ * Realized PnL summary for an account.
+ */
+interface RealizedPnL {
+  /** Total realized PnL for token 0 */
+  total0: bigint;
+  /** Total realized PnL for token 1 */
+  total1: bigint;
+  /** Number of closed positions */
+  positionCount: bigint;
+  /** Number of winning positions */
+  winCount: bigint;
+  /** Number of losing positions */
+  lossCount: bigint;
+}
+/**
+ * Stored position data (immutable fields only, no block metadata).
+ * Used for caching position data in storage.
+ */
+interface StoredPositionData {
+  /** The TokenId (256-bit identifier) */
+  tokenId: bigint;
+  /** Position size (number of contracts) */
+  positionSize: bigint;
+  /** Decoded legs */
+  legs: TokenIdLeg[];
+  /** Tick at the time of minting */
+  tickAtMint: bigint;
+  /** Pool utilization for token 0 at mint (0-10000 bps) */
+  poolUtilization0AtMint: bigint;
+  /** Pool utilization for token 1 at mint (0-10000 bps) */
+  poolUtilization1AtMint: bigint;
+  /** Timestamp at the time of minting (Unix seconds) */
+  timestampAtMint: bigint;
+  /** Block number at the time of minting */
+  blockNumberAtMint: bigint;
+  /** Whether a swap occurred at mint */
+  swapAtMint: boolean;
+}
+/**
+ * Stored pool metadata (immutable fields fetched from chain).
+ * Does NOT include poolAddress/chainId as those are storage key components.
+ */
+interface StoredPoolMeta {
+  /** Pool tick spacing */
+  tickSpacing: bigint;
+  /** Pool fee tier */
+  fee: bigint;
+  /** 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;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/account.d.ts
+/**
+ * Collateral data for a single token.
+ */
+interface TokenCollateral {
+  /** Total assets deposited (in underlying token) */
+  assets: bigint;
+  /** Collateral shares owned */
+  shares: bigint;
+  /** Available (unlocked) assets */
+  availableAssets: bigint;
+  /** Locked assets (used as collateral for positions) */
+  lockedAssets: bigint;
+}
+/**
+ * Account collateral data for both tokens.
+ */
+interface AccountCollateral {
+  /** Account address */
+  account: Address;
+  /** Pool address */
+  poolAddress: Address;
+  /** Token 0 collateral */
+  token0: TokenCollateral;
+  /** Token 1 collateral */
+  token1: TokenCollateral;
+  /** Number of open position legs */
+  legCount: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Base account summary for UI dashboards.
+ *
+ * This shape contains non-helper-dependent data only.
+ */
+interface AccountSummaryBasic {
+  /** Account address */
+  account: Address;
+  /** Pool data */
+  pool: Pool;
+  /** Collateral data */
+  collateral: AccountCollateral;
+  /** Open positions */
+  positions: Position[];
+  /** Health status of the pool */
+  healthStatus: PoolHealthStatus;
+  /** Whether wallet is on wrong network */
+  networkMismatch: boolean;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Risk-focused account summary for UI dashboards and bots.
+ *
+ * Includes everything in AccountSummaryBasic plus helper-dependent risk fields.
+ */
+interface AccountSummaryRisk extends AccountSummaryBasic {
+  /** Total position greeks */
+  totalGreeks: PositionGreeks;
+  /** Net liquidation value for token 0 */
+  netLiquidationValue0: bigint;
+  /** Net liquidation value for token 1 */
+  netLiquidationValue1: bigint;
+  /** Maintenance margin required for token 0 */
+  maintenanceMargin0: bigint;
+  /** Maintenance margin required for token 1 */
+  maintenanceMargin1: bigint;
+  /** Margin excess (positive) or deficit (negative) for token 0 */
+  marginExcess0: bigint;
+  /** Margin excess (positive) or deficit (negative) for token 1 */
+  marginExcess1: bigint;
+  /** Margin shortfall for token 0 (positive shortfall, negative excess) */
+  marginShortfall0: bigint;
+  /** Margin shortfall for token 1 (positive shortfall, negative excess) */
+  marginShortfall1: bigint;
+  /** Current margin (collateral balance) for token 0 */
+  currentMargin0: bigint;
+  /** Current margin (collateral balance) for token 1 */
+  currentMargin1: bigint;
+  /** Whether the account is liquidatable */
+  isLiquidatable: boolean;
+  /** Liquidation price bounds */
+  liquidationPrices: LiquidationPrices;
+}
+/**
+ * Net liquidation value result.
+ */
+interface NetLiquidationValue {
+  /** Net liquidation value for token 0 */
+  value0: bigint;
+  /** Net liquidation value for token 1 */
+  value1: bigint;
+  /** Tick used for calculation */
+  atTick: bigint;
+  /** Whether pending premium was included */
+  includedPendingPremium: boolean;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Net liquidation values at multiple ticks.
+ */
+interface NetLiquidationValues {
+  /** Net liquidation values for token 0 at each tick */
+  values0: bigint[];
+  /** Net liquidation values for token 1 at each tick */
+  values1: bigint[];
+  /** Ticks used for calculation */
+  atTicks: bigint[];
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Liquidation prices result.
+ */
+interface LiquidationPrices {
+  /** Lower liquidation tick (null if position is safe at MIN_TICK) */
+  lowerTick: bigint | null;
+  /** Upper liquidation tick (null if position is safe at MAX_TICK) */
+  upperTick: bigint | null;
+  /** Whether the account is currently liquidatable */
+  isLiquidatable: boolean;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Collateral estimate for a potential position.
+ */
+interface CollateralEstimate {
+  /** Required collateral for token 0 */
+  required0: bigint;
+  /** Required collateral for token 1 */
+  required1: bigint;
+  /** Post-position margin excess for token 0 */
+  postMarginExcess0: bigint;
+  /** Post-position margin excess for token 1 */
+  postMarginExcess1: bigint;
+  /** Whether the position would be openable */
+  canOpen: boolean;
+  /** 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/panoptic/v2/types/events.d.ts
+/**
+ * Supported Panoptic event types.
+ */
+type PanopticEventType = 'OptionMinted' | 'OptionBurnt' | 'AccountLiquidated' | 'ForcedExercised' | 'PremiumSettled' | 'Deposit' | 'Withdraw' | 'BorrowRateUpdated' | 'LiquidityChunkUpdated' | 'ProtocolLossRealized' | 'ModifyLiquidity' | 'Swap' | 'Donate';
+/**
+ * Base event data common to all events.
+ */
+interface BaseEvent {
+  /** Event type */
+  type: PanopticEventType;
+  /** Transaction hash */
+  transactionHash: Hash;
+  /** Block number */
+  blockNumber: bigint;
+  /** Block hash */
+  blockHash: Hash;
+  /** Log index within the block */
+  logIndex: bigint;
+}
+/**
+ * OptionMinted event data.
+ */
+interface OptionMintedEvent extends BaseEvent {
+  type: 'OptionMinted';
+  /** Recipient of the minted position */
+  recipient: Address;
+  /** TokenId of the minted position */
+  tokenId: bigint;
+  /** Position size */
+  positionSize: bigint;
+  /** Pool utilization for token 0 at mint */
+  poolUtilization0: bigint;
+  /** Pool utilization for token 1 at mint */
+  poolUtilization1: bigint;
+  /** Tick at mint */
+  tickAtMint: bigint;
+  /** Timestamp at mint (Unix seconds) */
+  timestampAtMint: bigint;
+  /** Block number at mint */
+  blockAtMint: bigint;
+  /** Whether a swap happened at mint */
+  swapAtMint: boolean;
+}
+/**
+ * OptionBurnt event data.
+ */
+interface OptionBurntEvent extends BaseEvent {
+  type: 'OptionBurnt';
+  /** Recipient (owner) of the burnt position */
+  recipient: Address;
+  /** TokenId of the burnt position */
+  tokenId: bigint;
+  /** Position size that was burnt */
+  positionSize: bigint;
+  /** Premia settled for each leg (token0 right, token1 left per leg) */
+  premiaByLeg: readonly [bigint, bigint, bigint, bigint];
+}
+/**
+ * AccountLiquidated event data.
+ */
+interface AccountLiquidatedEvent extends BaseEvent {
+  type: 'AccountLiquidated';
+  /** Address of the liquidator */
+  liquidator: Address;
+  /** Address of the liquidated account */
+  liquidatee: Address;
+  /** Bonus paid to liquidator for token 0 */
+  bonusAmount0: bigint;
+  /** Bonus paid to liquidator for token 1 */
+  bonusAmount1: bigint;
+}
+/**
+ * ForcedExercised event data.
+ */
+interface ForcedExercisedEvent extends BaseEvent {
+  type: 'ForcedExercised';
+  /** Address of the exerciser */
+  exercisor: Address;
+  /** Address of the position owner */
+  user: Address;
+  /** TokenId of the exercised position */
+  tokenId: bigint;
+  /** Exercise fee for token 0 (negative = cost to exerciser) */
+  exerciseFee0: bigint;
+  /** Exercise fee for token 1 (negative = cost to exerciser) */
+  exerciseFee1: bigint;
+}
+/**
+ * PremiumSettled event data.
+ */
+interface PremiumSettledEvent extends BaseEvent {
+  type: 'PremiumSettled';
+  /** Position owner */
+  user: Address;
+  /** TokenId */
+  tokenId: bigint;
+  /** Leg index that was settled */
+  legIndex: bigint;
+  /** Settled amount for token 0 */
+  settledAmount0: bigint;
+  /** Settled amount for token 1 */
+  settledAmount1: bigint;
+}
+/**
+ * Deposit event data (ERC4626).
+ */
+interface DepositEvent extends BaseEvent {
+  type: 'Deposit';
+  /** Sender address */
+  sender: Address;
+  /** Owner address */
+  owner: Address;
+  /** Assets deposited */
+  assets: bigint;
+  /** Shares minted */
+  shares: bigint;
+}
+/**
+ * Withdraw event data (ERC4626).
+ */
+interface WithdrawEvent extends BaseEvent {
+  type: 'Withdraw';
+  /** Sender address */
+  sender: Address;
+  /** Receiver address */
+  receiver: Address;
+  /** Owner address */
+  owner: Address;
+  /** Assets withdrawn */
+  assets: bigint;
+  /** Shares burned */
+  shares: bigint;
+}
+/**
+ * BorrowRateUpdated event data (RiskEngine).
+ */
+interface BorrowRateUpdatedEvent extends BaseEvent {
+  type: 'BorrowRateUpdated';
+  /** Collateral token address */
+  collateralToken: Address;
+  /** Average borrow rate */
+  avgBorrowRate: bigint;
+  /** Rate at target utilization */
+  rateAtTarget: bigint;
+}
+/**
+ * LiquidityChunkUpdated event data (SFPM).
+ */
+interface LiquidityChunkUpdatedEvent extends BaseEvent {
+  type: 'LiquidityChunkUpdated';
+  /** Pool ID (bytes32) */
+  poolId: Hash;
+  /** Owner address */
+  owner: Address;
+  /** Token type (0 or 1) */
+  tokenType: bigint;
+  /** Lower tick */
+  tickLower: number;
+  /** Upper tick */
+  tickUpper: number;
+  /** Liquidity delta (positive = added, negative = removed) */
+  liquidityDelta: bigint;
+}
+/**
+ * ProtocolLossRealized event data (CollateralTracker).
+ */
+interface ProtocolLossRealizedEvent extends BaseEvent {
+  type: 'ProtocolLossRealized';
+  /** Liquidated account */
+  liquidatee: Address;
+  /** Liquidator address */
+  liquidator: Address;
+  /** Protocol loss in assets */
+  protocolLossAssets: bigint;
+  /** Protocol loss in shares */
+  protocolLossShares: bigint;
+}
+/**
+ * ModifyLiquidity event data (v4 PoolManager).
+ */
+interface ModifyLiquidityEvent extends BaseEvent {
+  type: 'ModifyLiquidity';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Lower tick */
+  tickLower: number;
+  /** Upper tick */
+  tickUpper: number;
+  /** Liquidity delta */
+  liquidityDelta: bigint;
+  /** Salt */
+  salt: Hash;
+}
+/**
+ * Swap event data (v4 PoolManager).
+ */
+interface SwapEvent extends BaseEvent {
+  type: 'Swap';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Amount of token 0 */
+  amount0: bigint;
+  /** Amount of token 1 */
+  amount1: bigint;
+  /** Square root price X96 */
+  sqrtPriceX96: bigint;
+  /** Liquidity */
+  liquidity: bigint;
+  /** Tick */
+  tick: number;
+  /** Fee */
+  fee: number;
+}
+/**
+ * Donate event data (v4 PoolManager).
+ */
+interface DonateEvent extends BaseEvent {
+  type: 'Donate';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Amount of token 0 */
+  amount0: bigint;
+  /** Amount of token 1 */
+  amount1: bigint;
+}
+/**
+ * Union of all Panoptic event types.
+ */
+type PanopticEvent = OptionMintedEvent | OptionBurntEvent | AccountLiquidatedEvent | ForcedExercisedEvent | PremiumSettledEvent | DepositEvent | WithdrawEvent | BorrowRateUpdatedEvent | LiquidityChunkUpdatedEvent | ProtocolLossRealizedEvent | ModifyLiquidityEvent | SwapEvent | DonateEvent;
+/**
+ * Leg update data from events.
+ */
+interface LegUpdate {
+  /** Leg index */
+  legIndex: bigint;
+  /** Liquidity delta (positive = added, negative = removed) */
+  liquidityDelta: bigint;
+  /** Token 0 delta */
+  amount0Delta: bigint;
+  /** Token 1 delta */
+  amount1Delta: bigint;
+}
+/**
+ * Event subscription handle.
+ */
+interface EventSubscription {
+  /** Unsubscribe from events */
+  unsubscribe: () => void;
+  /** Current connection status */
+  isConnected: () => boolean;
+}
+/**
+ * Sync progress event for syncPositions callback.
+ */
+interface SyncEvent {
+  /** Current block being processed */
+  currentBlock: bigint;
+  /** Target block to sync to */
+  targetBlock: bigint;
+  /** Number of positions discovered so far */
+  positionsFound: bigint;
+  /** Percentage complete (0-100) */
+  progress: bigint;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/tx.d.ts
+/**
+ * Transaction result returned by write functions.
+ * Provides immediate access to hash and a wait function for confirmation.
+ */
+interface TxResult {
+  /** Transaction hash, available immediately */
+  hash: Hash;
+  /** Wait for transaction confirmation */
+  wait: (confirmations?: bigint) => Promise<TxReceipt>;
+}
+/**
+ * Transaction result with receipt already awaited.
+ * Returned by *AndWait convenience functions.
+ */
+interface TxResultWithReceipt extends TxResult {
+  /** The transaction receipt */
+  receipt: TxReceipt;
+}
+/**
+ * Transaction receipt after confirmation.
+ */
+interface TxReceipt {
+  /** Transaction hash */
+  hash: Hash;
+  /** Block number */
+  blockNumber: bigint;
+  /** Block hash */
+  blockHash: Hash;
+  /** Gas used */
+  gasUsed: bigint;
+  /** Transaction status */
+  status: 'success' | 'reverted';
+  /** Parsed Panoptic events from the transaction */
+  events: PanopticEvent[];
+}
+/**
+ * Transaction broadcaster interface for private transaction support.
+ * Allows plugging in Flashbots or other MEV protection services.
+ */
+interface TxBroadcaster {
+  /**
+   * Broadcast a signed transaction.
+   * @param signedTx - The signed transaction bytes
+   * @returns The transaction hash
+   */
+  broadcast: (signedTx: `0x${string}`) => Promise<Hash>;
+}
+/**
+ * Gas and transaction overrides for write operations.
+ * Supports EIP-1559 gas parameters, explicit nonce, and custom broadcasters.
+ */
+interface TxOverrides {
+  /** EIP-1559 max fee per gas */
+  maxFeePerGas?: bigint;
+  /** EIP-1559 max priority fee per gas (tip) */
+  maxPriorityFeePerGas?: bigint;
+  /** Gas limit override */
+  gas?: bigint;
+  /** Explicit nonce (for concurrent tx submission) */
+  nonce?: bigint;
+  /** Custom broadcaster for MEV protection (Flashbots, private mempool) */
+  broadcaster?: TxBroadcaster;
+}
+/**
+ * Nonce manager for concurrent transaction submission.
+ */
+interface NonceManager {
+  /** Get the next nonce for an account */
+  getNextNonce: (account: Address) => Promise<bigint>;
+  /** Reset nonce tracking (e.g., after failure) */
+  reset: (account: Address) => void;
+}
+/**
+ * Dispatch call for raw multi-operation transactions.
+ */
+interface DispatchCall {
+  /** TokenId to operate on */
+  tokenId: bigint;
+  /** Position size change (positive = mint, negative = burn) */
+  positionSize: bigint;
+  /** Whether this is a long (true) or short (false) */
+  isLong: boolean;
+  /** Recipient address (usually the sender) */
+  recipient?: Address;
+}
+
+//#endregion
+//#region src/panoptic/v2/errors/base.d.ts
+/**
+ * Base error class for the Panoptic v2 SDK.
+ * @module v2/errors/base
+ */
+/**
+ * Base error class for all Panoptic SDK errors.
+ * All errors thrown by the SDK extend this class.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await openPosition(config, params)
+ * } catch (error) {
+ *   if (error instanceof PanopticError) {
+ *     console.log('Panoptic error:', error.name, error.message)
+ *     console.log('Original cause:', error.cause)
+ *   }
+ * }
+ * ```
+ */
+declare class PanopticError extends Error {
+  readonly cause?: Error | undefined;
+  readonly name: string;
+  /** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
+  errorName?: string;
+  /**
+   * Creates a new PanopticError.
+   *
+   * @param message - Human-readable error message
+   * @param cause - Optional underlying error that caused this error
+   */
+  constructor(message: string, cause?: Error | undefined);
+}
+
+//#endregion
+//#region src/panoptic/v2/types/simulation.d.ts
+/**
+ * Token flow data from simulation.
+ * Measures collateral asset changes via getAssetsOf-dispatch-getAssetsOf pattern
+ * using PanopticPool.multicall.
+ */
+interface TokenFlow {
+  /** Token 0 collateral change (negative = user deposits, positive = user receives) */
+  delta0: bigint;
+  /** Token 1 collateral change (negative = user deposits, positive = user receives) */
+  delta1: bigint;
+  /** Collateral assets in token 0 before the call */
+  balanceBefore0: bigint;
+  /** Collateral assets in token 1 before the call */
+  balanceBefore1: bigint;
+  /** Collateral assets in token 0 after the call */
+  balanceAfter0: bigint;
+  /** Collateral assets in token 1 after the call */
+  balanceAfter1: bigint;
+  /** Pool tick before the operation */
+  tickBefore: bigint | null;
+  /** Pool tick after the operation */
+  tickAfter: bigint | null;
+}
+/**
+ * Simulation result discriminated union.
+ * Success case returns data, failure case returns error.
+ *
+ * Note: tokenFlow is optional because some simulations (deposit/withdraw)
+ * don't use the PanopticPool.multicall token flow measurement.
+ */
+type SimulationResult<T> = {
+  success: true;
+  data: T;
+  gasEstimate: bigint;
+  tokenFlow?: TokenFlow;
+  _meta: BlockMeta;
+} | {
+  success: false;
+  error: PanopticError;
+  _meta: BlockMeta;
+};
+/**
+ * Open position simulation result data.
+ */
+interface OpenPositionSimulation {
+  /** The position that would be created */
+  position: Position;
+  /** Post-trade greeks */
+  greeks: PositionGreeks;
+  /** Token 0 amount required */
+  amount0Required: bigint;
+  /** Token 1 amount required */
+  amount1Required: bigint;
+  /** Post-trade collateral for token 0 */
+  postCollateral0: bigint;
+  /** Post-trade collateral for token 1 */
+  postCollateral1: bigint;
+  /**
+   * Post-mint collateral requirement in token0, from getFullPositionsData.collateralRequirements[].
+   * Sum of per-position LeftRightUnsigned.right across all positions in finalPositionIdList.
+   */
+  postMintCollateralReqToken0: bigint;
+  /**
+   * Post-mint collateral requirement in token1, from getFullPositionsData.collateralRequirements[].
+   * Sum of per-position LeftRightUnsigned.left across all positions in finalPositionIdList.
+   */
+  postMintCollateralReqToken1: bigint;
+  /**
+   * Per-position collateral requirements from getFullPositionsData.collateralRequirements[].
+   * One entry per position in finalPositionIdList, in the same order.
+   */
+  perPositionCollateralReqs: {
+    token0: bigint;
+    token1: bigint;
+  }[];
+  /** Commission paid for token 0 (null: embedded in contract logic, not extractable from token flow) */
+  commission0: bigint | null;
+  /** Commission paid for token 1 (null: embedded in contract logic, not extractable from token flow) */
+  commission1: bigint | null;
+}
+/**
+ * Close position simulation result data.
+ */
+interface ClosePositionSimulation {
+  /** Token 0 amount received */
+  amount0Received: bigint;
+  /** Token 1 amount received */
+  amount1Received: bigint;
+  /** Premia collected for token 0 (null: requires pre-close premia snapshot) */
+  premiaCollected0: bigint | null;
+  /** Premia collected for token 1 (null: requires pre-close premia snapshot) */
+  premiaCollected1: bigint | null;
+  /** Post-trade collateral for token 0 */
+  postCollateral0: bigint;
+  /** Post-trade collateral for token 1 */
+  postCollateral1: bigint;
+  /** Realized PnL for token 0 (null: requires open position cost basis) */
+  realizedPnL0: bigint | null;
+  /** Realized PnL for token 1 (null: requires open position cost basis) */
+  realizedPnL1: bigint | null;
+}
+/**
+ * Force exercise simulation result data.
+ */
+interface ForceExerciseSimulation {
+  /** Exercise fee for token 0 (positive = received, negative = paid) */
+  exerciseFee0: bigint;
+  /** Exercise fee for token 1 */
+  exerciseFee1: bigint;
+  /** Whether the exercise would succeed */
+  canExercise: boolean;
+  /** Reason if cannot exercise */
+  reason?: string;
+}
+/**
+ * Liquidation simulation result data.
+ */
+interface LiquidateSimulation {
+  /** Bonus received for token 0 */
+  bonus0: bigint;
+  /** Bonus received for token 1 */
+  bonus1: bigint;
+  /** Positions that would be closed */
+  positionsClosed: bigint[];
+  /** Whether the account is liquidatable */
+  isLiquidatable: boolean;
+  /** Shortfall for token 0 (if liquidatable) */
+  shortfall0: bigint;
+  /** Shortfall for token 1 (if liquidatable) */
+  shortfall1: bigint;
+}
+/**
+ * Settle premia simulation result data.
+ */
+interface SettleSimulation {
+  /** Premia received for token 0 */
+  premiaReceived0: bigint;
+  /** Premia received for token 1 */
+  premiaReceived1: bigint;
+  /** Post-settle collateral for token 0 */
+  postCollateral0: bigint;
+  /** Post-settle collateral for token 1 */
+  postCollateral1: bigint;
+  /** Forfeit amounts [token0, token1] — present when tokenId was provided */
+  forfeitAmounts?: [bigint, bigint];
+}
+/**
+ * Deposit simulation result data.
+ */
+interface DepositSimulation {
+  /** Shares that would be minted */
+  sharesMinted: bigint;
+  /** Post-deposit assets */
+  postAssets: bigint;
+  /** Post-deposit shares */
+  postShares: bigint;
+}
+/**
+ * Withdraw simulation result data.
+ */
+interface WithdrawSimulation {
+  /** Shares that would be burned */
+  sharesBurned: bigint;
+  /** Assets that would be received */
+  assetsReceived: bigint;
+  /** Post-withdraw assets */
+  postAssets: bigint;
+  /** Post-withdraw shares */
+  postShares: bigint;
+  /** Whether the withdrawal is possible */
+  canWithdraw: boolean;
+  /** Reason if cannot withdraw */
+  reason?: string;
+}
+/**
+ * Dispatch simulation result data.
+ */
+interface DispatchSimulation {
+  /** Token 0 net change */
+  netAmount0: bigint;
+  /** Token 1 net change */
+  netAmount1: bigint;
+  /** Positions created */
+  positionsCreated: bigint[];
+  /** Positions closed */
+  positionsClosed: bigint[];
+  /** Post-dispatch collateral for token 0 */
+  postCollateral0: bigint;
+  /** Post-dispatch collateral for token 1 */
+  postCollateral1: bigint;
+  /** Post-dispatch margin excess for token 0 (null if full positions decode/token-flow balances are unavailable or omitted; see simulateDispatch/getFullPositionsData). */
+  postMarginExcess0: bigint | null;
+  /** Post-dispatch margin excess for token 1 (null if full positions decode/token-flow balances are unavailable or omitted; see simulateDispatch/getFullPositionsData). */
+  postMarginExcess1: bigint | null;
+  /** Pre-dispatch margin excess for token 0 (null if full positions decode/token-flow balances are unavailable or omitted; see simulateDispatch/getFullPositionsData). */
+  preMarginExcess0: bigint | null;
+  /** Pre-dispatch margin excess for token 1 (null if full positions decode/token-flow balances are unavailable or omitted; see simulateDispatch/getFullPositionsData). */
+  preMarginExcess1: bigint | null;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/chunks.d.ts
+/**
+ * Chunk spread represents a range of ticks being tracked.
+ * Used to organize position data for efficient storage and retrieval.
+ */
+interface ChunkSpread {
+  /** Lower tick bound (inclusive) */
+  tickLower: bigint;
+  /** Upper tick bound (exclusive) */
+  tickUpper: bigint;
+  /** Pool address */
+  poolAddress: Address;
+  /** Chain ID */
+  chainId: bigint;
+}
+/**
+ * Chunk key for storage lookup.
+ * Format: chain{chainId}:pool{poolAddress}:chunk{tickLower}:{tickUpper}
+ */
+interface ChunkKey {
+  /** Chain ID */
+  chainId: bigint;
+  /** Pool address */
+  poolAddress: Address;
+  /** Lower tick bound */
+  tickLower: bigint;
+  /** Upper tick bound */
+  tickUpper: bigint;
+}
+/**
+ * Chunk data stored in persistent storage.
+ */
+interface ChunkData {
+  /** The chunk key */
+  key: ChunkKey;
+  /** Token IDs in this chunk */
+  tokenIds: bigint[];
+  /** Last update block number */
+  lastBlock: bigint;
+  /** Last update block hash */
+  lastBlockHash: Hash;
+  /** Creation timestamp */
+  createdAt: bigint;
+  /** Last update timestamp */
+  updatedAt: bigint;
+}
+/**
+ * Chunk metadata for LRU eviction.
+ */
+interface ChunkMetadata {
+  /** The chunk key */
+  key: ChunkKey;
+  /** Access count for frequency-based eviction */
+  accessCount: bigint;
+  /** Last access timestamp */
+  lastAccessedAt: bigint;
+  /** Size in bytes (approximate) */
+  sizeBytes: bigint;
+}
+/**
+ * Chunk statistics for monitoring.
+ */
+interface ChunkStats {
+  /** Total number of chunks */
+  totalChunks: bigint;
+  /** Total token IDs across all chunks */
+  totalTokenIds: bigint;
+  /** Oldest chunk timestamp */
+  oldestChunk: bigint;
+  /** Newest chunk timestamp */
+  newestChunk: bigint;
+  /** Average chunk size */
+  avgChunkSize: bigint;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/poolConfig.d.ts
+/** V3 pool configuration. */
+interface V3PoolConfig {
+  version: 'v3';
+  /** Uniswap V3 pool contract address */
+  poolAddress: Address;
+}
+/** V4 pool configuration. */
+interface V4PoolConfig {
+  version: 'v4';
+  /** StateView contract address */
+  stateViewAddress: Address;
+  /** V4 pool ID (bytes32) */
+  poolId: `0x${string}`;
+}
+/** Discriminated union of V3 and V4 pool configurations. */
+type PoolVersionConfig = V3PoolConfig | V4PoolConfig;
+
+//#endregion
+//#region src/panoptic/v2/types/sync.d.ts
+/**
+ * Sync status enum.
+ */
+type SyncStatus = 'idle' | 'syncing' | 'error' | 'complete';
+/**
+ * Sync state for tracking synchronization progress.
+ */
+interface SyncState {
+  /** Current sync status */
+  status: SyncStatus;
+  /** Last synced block number */
+  lastSyncedBlock: bigint;
+  /** Last synced block hash */
+  lastSyncedBlockHash: Hash;
+  /** Target block to sync to */
+  targetBlock: bigint;
+  /** Number of positions found during sync */
+  positionsFound: bigint;
+  /** Progress percentage (0-100) */
+  progress: bigint;
+  /** Error message if status is 'error' */
+  errorMessage?: string;
+  /** Timestamp when sync started */
+  startedAt: bigint;
+  /** Timestamp when sync completed (or errored) */
+  completedAt?: bigint;
+}
+/**
+ * Sync checkpoint for resumable syncs.
+ */
+interface SyncCheckpoint {
+  /** Chain ID */
+  chainId: bigint;
+  /** Pool address being synced */
+  poolAddress: Address;
+  /** Account address being synced */
+  account: Address;
+  /** Last processed block */
+  lastBlock: bigint;
+  /** Last processed block hash */
+  lastBlockHash: Hash;
+  /** Positions discovered so far */
+  positionIds: bigint[];
+  /** Checkpoint creation timestamp */
+  createdAt: bigint;
+}
+/**
+ * Sync options for customizing sync behavior.
+ */
+interface SyncOptions {
+  /** Starting block for sync (defaults to pool deployment block) */
+  fromBlock?: bigint;
+  /** Ending block for sync (defaults to latest) */
+  toBlock?: bigint;
+  /** Batch size for event fetching */
+  batchSize?: bigint;
+  /** Whether to use checkpoints for resumable syncs */
+  useCheckpoints?: boolean;
+  /** Progress callback */
+  onProgress?: (state: SyncState) => void;
+}
+/**
+ * Sync result after completion.
+ */
+interface SyncResult {
+  /** Whether sync completed successfully */
+  success: boolean;
+  /** Final sync state */
+  state: SyncState;
+  /** Position IDs discovered */
+  positionIds: bigint[];
+  /** Number of blocks processed */
+  blocksProcessed: bigint;
+  /** Duration in milliseconds */
+  durationMs: bigint;
+}
+/**
+ * Reorg detection result.
+ */
+interface ReorgDetection {
+  /** Whether a reorg was detected */
+  detected: boolean;
+  /** Block number where reorg started (if detected) */
+  reorgBlock?: bigint;
+  /** Expected block hash */
+  expectedHash?: Hash;
+  /** Actual block hash */
+  actualHash?: Hash;
+  /** Number of blocks to resync */
+  blocksToResync?: bigint;
+}
+
+//#endregion
+export { AccountCollateral, AccountLiquidatedEvent, AccountSummaryBasic, AccountSummaryRisk, BaseEvent, BlockMeta, BorrowRateUpdatedEvent, ChunkData, ChunkKey, ChunkMetadata, ChunkSpread, ChunkStats, ClosePositionSimulation, ClosedPosition, CollateralEstimate, CollateralTracker, CurrentRates, DepositEvent, DepositSimulation, DispatchCall, DispatchSimulation, DonateEvent, EventSubscription, FetchPoolIdParams, FetchPoolIdResult, ForceExerciseSimulation, ForcedExercisedEvent, GetOracleStateParams, GetPoolMetadataParams, GetPoolParams, GetRiskParametersParams, GetUtilizationParams, LegGreeksParams, LegUpdate, LiquidateSimulation, LiquidationPrices, LiquidityChunkUpdatedEvent, ModifyLiquidityEvent, NetLiquidationValue, NetLiquidationValues, NonceManager, OpenPositionSimulation, OptionBurntEvent, OptionMintedEvent, OracleState, PanopticError, PanopticEvent, PanopticEventType, Pool, PoolHealthStatus, PoolKey, PoolMetadata, PoolVersionConfig, Position, PositionGreeks, PremiumSettledEvent, ProtocolLossRealizedEvent, RealizedPnL, ReorgDetection, RiskEngine, RiskParameters, SafeMode, SafeModeState, SettleSimulation, SimulationResult, StoredPoolMeta, StoredPositionData, SwapEvent, SyncCheckpoint, SyncEvent, SyncOptions, SyncResult, SyncState, SyncStatus, TickLimitsResult, TokenCollateral, TokenFlow, TokenIdLeg, TxBroadcaster, TxOverrides, TxReceipt, TxResult, TxResultWithReceipt, Utilization, V3PoolConfig, V4PoolConfig, WithdrawEvent, WithdrawSimulation, fetchPoolId, formatPriceRange, formatTick, formatTickRange, getOracleState, getPool, getPoolMetadata, getPricesAtTick, getRiskParameters, getTickSpacing, getUtilization, priceToTick, roundToTickSpacing, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, validateBuilderCode };
+//# sourceMappingURL=index-DVMjZi1E.d.ts.map