@panoptic-eng/sdk 1.0.27 → 1.0.28

package/dist/panoptic/v2/react-public.js

@@ -0,0 +1,3854 @@
+import { BORROW_INDEX_BITS, BPS_SCALE, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, UNREALIZED_INTEREST_BITS, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad$1 as formatRateWad, formatTokenAmount$1 as formatTokenAmount, formatTokenAmountSigned$1 as formatTokenAmountSigned, formatTokenDelta$1 as formatTokenDelta, formatTokenFlow$1 as formatTokenFlow, formatWad$1 as formatWad, formatWadPercent$1 as formatWadPercent, formatWadSigned$1 as formatWadSigned, getAccountCollateral$1 as getAccountCollateral, getAccountSummaryBasic$1 as getAccountSummaryBasic, getAccountSummaryRisk$1 as getAccountSummaryRisk, getChainDeployment, getCollateralAddresses$1 as getCollateralAddresses, getCollateralData$1 as getCollateralData, getCurrentRates$1 as getCurrentRates, getInterestState$1 as getInterestState, getIrmCurrent, getIrmCurve, getLiquidationPrices$1 as getLiquidationPrices, getNetLiquidationValue$1 as getNetLiquidationValue, getNetLiquidationValues$1 as getNetLiquidationValues, isLiquidatable$1 as isLiquidatable, isSupportedChain, packMarketState, parseTokenAmount$1 as parseTokenAmount, parseWad$1 as parseWad, ratePerSecWadToAprPct, requireChainDeployment, utilizationBpsToWad, utilizationPctToWad } from "../../irm-B0Bgj0z8.js";
+import { AccountInsolventError$1 as AccountInsolventError, AlreadyInitializedError$1 as AlreadyInitializedError, BatchValidationError$1 as BatchValidationError, BelowMinimumRedemptionError$1 as BelowMinimumRedemptionError, CastingError$1 as CastingError, ChunkHasZeroLiquidityError$1 as ChunkHasZeroLiquidityError, ChunkLimitError$1 as ChunkLimitError, CrossPoolError$1 as CrossPoolError, DEFAULT_MAX_SPREAD$1 as DEFAULT_MAX_SPREAD, DEFAULT_VEGOID$1 as DEFAULT_VEGOID, DepositTooLargeError$1 as DepositTooLargeError, DuplicateTokenIdError$1 as DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError$1 as EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError$1 as ExceedsMaximumRedemptionError, InputListFailError$1 as InputListFailError, InsufficientCreditLiquidityError$1 as InsufficientCreditLiquidityError, InvalidBuilderCodeError$1 as InvalidBuilderCodeError, InvalidHistoryRangeError$1 as InvalidHistoryRangeError, InvalidTickBoundError$1 as InvalidTickBoundError, InvalidTickError$1 as InvalidTickError, InvalidTokenIdParameterError$1 as InvalidTokenIdParameterError, InvalidUniswapCallbackError$1 as InvalidUniswapCallbackError, LEG_BITS$1 as LEG_BITS, LEG_LIMITS$1 as LEG_LIMITS, LEG_MASKS$1 as LEG_MASKS, LengthMismatchError$1 as LengthMismatchError, LiquidityTooHighError$1 as LiquidityTooHighError, LoanSlotExhaustedError$1 as LoanSlotExhaustedError, MaxRetriesExceededError$1 as MaxRetriesExceededError, MissingPositionIdsError$1 as MissingPositionIdsError, NetLiquidityZeroError$1 as NetLiquidityZeroError, NetworkMismatchError$1 as NetworkMismatchError, NoLegsExercisableError$1 as NoLegsExercisableError, NotALongLegError$1 as NotALongLegError, NotBuilderError$1 as NotBuilderError, NotEnoughLiquidityInChunkError$1 as NotEnoughLiquidityInChunkError, NotEnoughTokensError$1 as NotEnoughTokensError, NotGuardianError$1 as NotGuardianError, NotMarginCalledError$1 as NotMarginCalledError, NotPanopticPoolError$1 as NotPanopticPoolError, OracleRateLimitedError$1 as OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError$1 as PanopticHelperNotDeployedError, PanopticValidationError$1 as PanopticValidationError, PoolNotInitializedError$1 as PoolNotInitializedError, PositionCountNotZeroError$1 as PositionCountNotZeroError, PositionNotOwnedError$1 as PositionNotOwnedError, PositionSnapshotNotFoundError$1 as PositionSnapshotNotFoundError, PositionTooLargeError$1 as PositionTooLargeError, PriceBoundFailError$1 as PriceBoundFailError, PriceImpactTooLargeError$1 as PriceImpactTooLargeError, ProviderLagError$1 as ProviderLagError, ReentrancyError$1 as ReentrancyError, RpcError$1 as RpcError, RpcResponseError$1 as RpcResponseError, STANDARD_TICK_WIDTHS$1 as STANDARD_TICK_WIDTHS, SafeModeError$1 as SafeModeError, StaleDataError$1 as StaleDataError, StaleOracleError$1 as StaleOracleError, SwapTokenMismatchError$1 as SwapTokenMismatchError, SyncTimeoutError$1 as SyncTimeoutError, TOKEN_ID_BITS$1 as TOKEN_ID_BITS, TokenIdHasZeroLegsError$1 as TokenIdHasZeroLegsError, TooManyLegsOpenError$1 as TooManyLegsOpenError, TransferFailedError$1 as TransferFailedError, UnauthorizedUniswapCallbackError$1 as UnauthorizedUniswapCallbackError, UnderOverFlowError$1 as UnderOverFlowError, UnhealthyPoolError$1 as UnhealthyPoolError, WrongPoolIdError$1 as WrongPoolIdError, WrongUniswapPoolError$1 as WrongUniswapPoolError, ZeroAddressError$1 as ZeroAddressError, ZeroCollateralRequirementError$1 as ZeroCollateralRequirementError, collateralTrackerV2Abi, decodeLeftRightSigned$1 as decodeLeftRightSigned, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, fetchPoolId, getBlockMeta$1 as getBlockMeta, getOracleState, getPool, getPoolMetadata, getPosition$1 as getPosition, getPositionGreeks$1 as getPositionGreeks, getPositions$1 as getPositions, getRiskParameters, getUtilization, isPanopticErrorType$1 as isPanopticErrorType, panopticPoolV2Abi, parsePanopticError$1 as parsePanopticError, validateBuilderCode } from "../../position-R0IGLpQS.js";
+import { BPS_DENOMINATOR, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, ORACLE_EPOCH_SECONDS, REORG_DEPTH, SCHEMA_VERSION, STORAGE_PREFIX, UTILIZATION_DENOMINATOR, WAD, ZERO_COLLATERAL, ZERO_VALUATION, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, formatPriceRange, formatTick, formatTickRange, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getPricesAtTick, getTickSpacing, isCall, isDefinedRisk, priceToTick, roundToTickSpacing, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick } from "../../greeks-GysWXct-.js";
+import { approveErc20ForCow, cancelCowOrder, checkCowApproval, getCowOrderStatus, isCowSupportedChain, quoteCowSwap, signAndSubmitCowOrder } from "../../cow-Boc-39-Y.js";
+import { addLegToTokenId$1 as addLegToTokenId, approve$1 as approve, approveAndWait$1 as approveAndWait, approvePool$1 as approvePool, assertCanBurn$1 as assertCanBurn, assertCanForceExercise$1 as assertCanForceExercise, assertCanLiquidate$1 as assertCanLiquidate, assertCanMint$1 as assertCanMint, assertFresh$1 as assertFresh, assertHealthy$1 as assertHealthy, assertTradeable$1 as assertTradeable, borrow$1 as borrow, borrowAndWait$1 as borrowAndWait, buildBatchDispatchArgs$1 as buildBatchDispatchArgs, buildOpenPositionCalldata$1 as buildOpenPositionCalldata, buildUniqueLoan$1 as buildUniqueLoan, calculateResyncBlock$1 as calculateResyncBlock, cancelTransaction$1 as cancelTransaction, checkApproval$1 as checkApproval, clearCheckpoint$1 as clearCheckpoint, clearTrackedPositions$1 as clearTrackedPositions, closePosition$1 as closePosition, closePositionAndWait$1 as closePositionAndWait, countLegs$1 as countLegs, createFileStorage$1 as createFileStorage, createMemoryStorage$1 as createMemoryStorage, createNonceManager$1 as createNonceManager, createTokenIdBuilder$1 as createTokenIdBuilder, decodeAllDispatchCalldata$1 as decodeAllDispatchCalldata, decodeAllLegs$1 as decodeAllLegs, decodeDispatchCalldata$1 as decodeDispatchCalldata, decodeLeg$1 as decodeLeg, decodePoolId$1 as decodePoolId, decodeTickSpacing$2 as decodeTickSpacing, decodeTokenId$1 as decodeTokenId, decodeVegoid$1 as decodeVegoid, deployNewPool$1 as deployNewPool, deployNewPoolAndWait$1 as deployNewPoolAndWait, deposit$1 as deposit, depositAndWait$1 as depositAndWait, detectReorg$1 as detectReorg, dispatch$1 as dispatch, dispatchAndWait$1 as dispatchAndWait, encodeLeg$1 as encodeLeg, encodePoolId$1 as encodePoolId, encodeV4PoolId$1 as encodeV4PoolId, executeBatchDispatch$1 as executeBatchDispatch, executeBatchDispatchAndWait$1 as executeBatchDispatchAndWait, forceExercise$1 as forceExercise, forceExerciseAndWait$1 as forceExerciseAndWait, getAssetIndex$1 as getAssetIndex, getClosedPositionsKey$1 as getClosedPositionsKey, getOpenPositionIds$1 as getOpenPositionIds, getPendingPositionsKey$1 as getPendingPositionsKey, getPoolMetaKey$1 as getPoolMetaKey, getPoolPrefix$1 as getPoolPrefix, getPositionMetaKey$1 as getPositionMetaKey, getPositionsKey$1 as getPositionsKey, getSchemaVersionKey$1 as getSchemaVersionKey, getSyncCheckpointKey$1 as getSyncCheckpointKey, getTrackedChunksKey$1 as getTrackedChunksKey, getTrackedPositionIds$1 as getTrackedPositionIds, hasLoanOrCredit$1 as hasLoanOrCredit, hasLongLeg$1 as hasLongLeg, isCredit$1 as isCredit, isCreditLeg$1 as isCreditLeg, isGasError$1 as isGasError, isInputListFailError$1 as isInputListFailError, isLoan$1 as isLoan, isLoanLeg$1 as isLoanLeg, isNonceError$1 as isNonceError, isPositionTracked$1 as isPositionTracked, isRetryableRpcError$1 as isRetryableRpcError, isShortOnly$1 as isShortOnly, isSpread$1 as isSpread, jsonSerializer$1 as jsonSerializer, liquidate$1 as liquidate, liquidateAndWait$1 as liquidateAndWait, loadCheckpoint$1 as loadCheckpoint, mint$1 as mint, mintAndWait$1 as mintAndWait, openPosition$1 as openPosition, openPositionAndWait$1 as openPositionAndWait, pokeOracle$1 as pokeOracle, pokeOracleAndWait$1 as pokeOracleAndWait, previewBorrow$1 as previewBorrow, previewUnwrap$1 as previewUnwrap, previewWrap$1 as previewWrap, publicBroadcaster$1 as publicBroadcaster, recoverSnapshot$1 as recoverSnapshot, recoverSnapshotFromTx$1 as recoverSnapshotFromTx, redeem$1 as redeem, redeemAndWait$1 as redeemAndWait, repay$1 as repay, repayAndWait$1 as repayAndWait, resolveTokenIndex$1 as resolveTokenIndex, rollPosition$1 as rollPosition, rollPositionAndWait$1 as rollPositionAndWait, saveCheckpoint$1 as saveCheckpoint, selectDispatchForAccount$1 as selectDispatchForAccount, settleAccumulatedPremia$1 as settleAccumulatedPremia, settleAccumulatedPremiaAndWait$1 as settleAccumulatedPremiaAndWait, simulateOpenPosition$1 as simulateOpenPosition, smartRepay$1 as smartRepay, smartRepayAndWait$1 as smartRepayAndWait, speedUpTransaction$1 as speedUpTransaction, supply$1 as supply, supplyAndWait$1 as supplyAndWait, swapExactIn$1 as swapExactIn, swapExactInAndWait$1 as swapExactInAndWait, swapExactOut$1 as swapExactOut, swapExactOutAndWait$1 as swapExactOutAndWait, syncPositions$1 as syncPositions, unsupply$1 as unsupply, unsupplyAndWait$1 as unsupplyAndWait, unwrapWeth$1 as unwrapWeth, unwrapWethAndWait$1 as unwrapWethAndWait, unwrapXstock$1 as unwrapXstock, unwrapXstockAndWait$1 as unwrapXstockAndWait, validateBatch$1 as validateBatch, validatePoolId$1 as validatePoolId, verifyBlockContinuity$1 as verifyBlockContinuity, wethWrapAbi$1 as wethWrapAbi, withdraw$1 as withdraw, withdrawAndWait$1 as withdrawAndWait, withdrawWithPositions$1 as withdrawWithPositions, withdrawWithPositionsAndWait$1 as withdrawWithPositionsAndWait, wrapEth$1 as wrapEth, wrapEthAndWait$1 as wrapEthAndWait, wrapXstock$1 as wrapXstock, wrapXstockAndWait$1 as wrapXstockAndWait, xstockWrapperAbi$1 as xstockWrapperAbi } from "../../writes-Dhzpw0dq.js";
+import { DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, encodePoolKeyBytes, encodeV3PoolKeyBytes, estimateBlockNumbers, estimateCollateralRequired, failPendingPosition, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxWithdrawable, getNativeTokenPrice, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionsWithPremia, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTokenListId, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, previewDeposit, previewMint, previewRedeem, previewWithdraw, reconstructFromEvents, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, truncateAddress, watchEvents } from "../../v2-CkOo7vW2.js";
+import { approveErc20ForPermit2, approveRouterViaPermit2, checkRouterApproval, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, swapExactInViaRouter, swapExactOutViaRouter } from "../../router-NPhQUNh4.js";
+import { zeroAddress } from "viem";
+import { createContext, useContext, useEffect, useRef, useState } from "react";
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/panoptic/v2/react/cacheScopes.ts
+/**
+* Stable cache-scope helpers for React query keys.
+* @module v2/react/cacheScopes
+*/
+const DEFAULT_CLIENT_CACHE_SCOPE = "default-client";
+const DEFAULT_STORAGE_CACHE_SCOPE = "default-storage";
+function getClientCacheScope(scope) {
+	return scope ?? DEFAULT_CLIENT_CACHE_SCOPE;
+}
+function getStorageCacheScope(scope) {
+	return scope ?? DEFAULT_STORAGE_CACHE_SCOPE;
+}
+function getClientCacheScopeKey(client, scope) {
+	return getClientCacheScope(scope);
+}
+function getStorageCacheScopeKey(storage, scope) {
+	return getStorageCacheScope(scope);
+}
+function getAtTickCacheKey(atTick) {
+	return atTick === void 0 ? "latest" : atTick.toString();
+}
+
+//#endregion
+//#region src/panoptic/v2/react/provider.tsx
+const PanopticContext = createContext(null);
+/**
+* Context provider for Panoptic v2 SDK hooks.
+*
+* Wraps children with shared publicClient, walletClient, account, chainId, and storage.
+* Does NOT include QueryClientProvider — you must provide your own.
+*
+* @example
+* ```tsx
+* <QueryClientProvider client={queryClient}>
+*   <PanopticProvider
+*     publicClient={publicClient}
+*     walletClient={walletClient}
+*     account={address}
+*     chainId={1n}
+*   >
+*     <App />
+*   </PanopticProvider>
+* </QueryClientProvider>
+* ```
+*/
+function PanopticProvider({ children,...value }) {
+	return /* @__PURE__ */ jsx(PanopticContext.Provider, {
+		value,
+		children
+	});
+}
+/**
+* Access the Panoptic SDK context.
+*
+* @throws Error if used outside PanopticProvider
+* @returns PanopticContextValue
+*/
+function usePanopticContext() {
+	const ctx = useContext(PanopticContext);
+	if (!ctx) throw new Error("usePanopticContext must be used within a PanopticProvider");
+	return ctx;
+}
+/**
+* Internal hook that requires storage adapter.
+*
+* @throws Error if storage not provided in context
+* @returns StorageAdapter guaranteed non-undefined
+*/
+function useRequireStorage() {
+	const { storage } = usePanopticContext();
+	if (!storage) throw new Error("storage is required. Provide a StorageAdapter via PanopticProvider.");
+	return storage;
+}
+
+//#endregion
+//#region src/panoptic/v2/react/queryKeys.ts
+/**
+* Query key factory for Panoptic v2 SDK data.
+*
+* Use with TanStack Query or SWR for cache key consistency.
+* All keys are arrays for proper cache matching and invalidation.
+*
+* @example
+* ```typescript
+* import { useQuery } from '@tanstack/react-query'
+* import { queryKeys, getPool } from 'panoptic-v2-sdk'
+*
+* function usePool(config: PanopticConfig) {
+*   return useQuery({
+*     queryKey: queryKeys.pool(config.chainId, config.poolAddress),
+*     queryFn: () => getPool(config),
+*   })
+* }
+* ```
+*/
+const queryKeys = {
+	all: ["panoptic-v2"],
+	pool: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"pool",
+		chainId.toString(),
+		poolAddress
+	],
+	utilization: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"utilization",
+		chainId.toString(),
+		poolAddress
+	],
+	oracle: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"oracle",
+		chainId.toString(),
+		poolAddress
+	],
+	safeMode: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"safeMode",
+		chainId.toString(),
+		poolAddress
+	],
+	guardianUnlock: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"guardianUnlock",
+		chainId.toString(),
+		poolAddress
+	],
+	riskParameters: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"riskParameters",
+		chainId.toString(),
+		poolAddress
+	],
+	rates: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"rates",
+		chainId.toString(),
+		poolAddress
+	],
+	position: (chainId, poolAddress, tokenId) => [
+		...queryKeys.all,
+		"position",
+		chainId.toString(),
+		poolAddress,
+		tokenId.toString()
+	],
+	positions: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"positions",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	trackedPositionIds: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"trackedPositionIds",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	syncStatus: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"syncStatus",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	accountCollateral: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"accountCollateral",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	accountSummaryBasic: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"accountSummaryBasic",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	accountSummaryRisk: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"accountSummaryRisk",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	isLiquidatable: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"isLiquidatable",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	liquidationPrices: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"liquidationPrices",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	netLiquidationValue: (chainId, poolAddress, account, atTick) => [
+		...queryKeys.all,
+		"netLiquidationValue",
+		chainId.toString(),
+		poolAddress,
+		account,
+		atTick.toString()
+	],
+	chunkSpreads: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"chunkSpreads",
+		chainId.toString(),
+		poolAddress
+	],
+	closedPositions: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"closedPositions",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	tradeHistory: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"tradeHistory",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	realizedPnL: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"realizedPnL",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	positionGreeks: (chainId, poolAddress, tokenId) => [
+		...queryKeys.all,
+		"positionGreeks",
+		chainId.toString(),
+		poolAddress,
+		tokenId.toString()
+	],
+	accountGreeks: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"accountGreeks",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	collateralEstimate: (chainId, poolAddress, account, tokenId) => [
+		...queryKeys.all,
+		"collateralEstimate",
+		chainId.toString(),
+		poolAddress,
+		account,
+		tokenId.toString()
+	],
+	maxPositionSize: (chainId, poolAddress, account, tokenId) => [
+		...queryKeys.all,
+		"maxPositionSize",
+		chainId.toString(),
+		poolAddress,
+		account,
+		tokenId.toString()
+	],
+	maxWithdrawable: (chainId, collateralTrackerAddress, positionIdList, totalAssets, account) => [
+		...queryKeys.all,
+		chainId.toString(),
+		"maxWithdrawable",
+		collateralTrackerAddress,
+		positionIdList.map(String).join(","),
+		totalAssets.toString(),
+		account
+	],
+	approval: (chainId, token, owner, spender) => [
+		...queryKeys.all,
+		"approval",
+		chainId.toString(),
+		token,
+		owner,
+		spender
+	],
+	erc4626Preview: (chainId, tracker, operation, amount) => [
+		...queryKeys.all,
+		"erc4626Preview",
+		chainId.toString(),
+		tracker,
+		operation,
+		amount.toString()
+	],
+	marginBuffer: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"marginBuffer",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	accountPremia: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"accountPremia",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	positionsWithPremia: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"positionsWithPremia",
+		chainId.toString(),
+		poolAddress,
+		account
+	],
+	collateralData: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"collateralData",
+		chainId.toString(),
+		poolAddress
+	],
+	poolLiquidities: (chainId, poolAddress) => [
+		...queryKeys.all,
+		"poolLiquidities",
+		chainId.toString(),
+		poolAddress
+	],
+	optimizeRiskPartners: (chainId, poolAddress, tokenId) => [
+		...queryKeys.all,
+		"optimizeRiskPartners",
+		chainId.toString(),
+		poolAddress,
+		tokenId.toString()
+	],
+	priceHistory: (chainId, poolAddress, timestampsHash) => [
+		...queryKeys.all,
+		"priceHistory",
+		chainId.toString(),
+		poolAddress,
+		timestampsHash
+	],
+	streamiaHistory: (chainId, poolAddress, rangeHash) => [
+		...queryKeys.all,
+		"streamiaHistory",
+		chainId.toString(),
+		poolAddress,
+		rangeHash
+	],
+	uniswapFeeHistory: (chainId, poolAddress, rangeHash) => [
+		...queryKeys.all,
+		"uniswapFeeHistory",
+		chainId.toString(),
+		poolAddress,
+		rangeHash
+	],
+	requiredCreditForITM: (chainId, poolAddress, account, tokenId) => [
+		...queryKeys.all,
+		"requiredCreditForITM",
+		chainId.toString(),
+		poolAddress,
+		account,
+		tokenId.toString()
+	],
+	flowNeutralTokenId: (chainId, poolAddress, tokenId) => [
+		...queryKeys.all,
+		"flowNeutralTokenId",
+		chainId.toString(),
+		poolAddress,
+		tokenId.toString()
+	],
+	interestState: (chainId, poolAddress, account) => [
+		...queryKeys.all,
+		"interestState",
+		chainId.toString(),
+		poolAddress,
+		account
+	]
+};
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/reads.ts
+function usePool(poolAddress, options) {
+	const { publicClient, chainId, clientScope, stateViewAddress } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.pool(chainId, poolAddress),
+			getClientCacheScopeKey(publicClient, clientScope),
+			stateViewAddress
+		],
+		queryFn: () => getPool({
+			client: publicClient,
+			poolAddress,
+			chainId,
+			stateViewAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useUtilization(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.utilization(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getUtilization({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useOracleState(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.oracle(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getOracleState({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useRiskParameters(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.riskParameters(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getRiskParameters({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useCurrentRates(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.rates(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getCurrentRates({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useSafeMode(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.safeMode(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getSafeMode({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* React hook for the Guardian pending-unlock state of a pool.
+*
+* Reads `unlockEta` + `isPoolUnlockReady` from the PanopticGuardian so the UI
+* can surface the unlock timelock while a pool is locked (close-only). Gate it
+* via `options.enabled` so it only runs when the pool is actually locked.
+*
+* @param poolAddress - The PanopticPool address
+* @param options - Optional react-query settings (enabled, refetchInterval, staleTime, gcTime)
+* @returns A react-query result whose `data` is a `GuardianUnlockState`
+*/
+function useGuardianUnlockState(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [...queryKeys.guardianUnlock(chainId, poolAddress), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: () => getGuardianUnlockState({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useCollateralData(poolAddress, tokenIndex, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.collateralData(chainId, poolAddress),
+			getClientCacheScopeKey(publicClient, clientScope),
+			tokenIndex
+		],
+		queryFn: () => getCollateralData({
+			client: publicClient,
+			poolAddress,
+			tokenIndex
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePoolLiquidities(poolAddress, params, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.poolLiquidities(chainId, poolAddress),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params.queryAddress,
+			params.startTick,
+			params.nTicks
+		],
+		queryFn: () => getPoolLiquidities({
+			client: publicClient,
+			poolAddress,
+			queryAddress: params.queryAddress,
+			startTick: params.startTick,
+			nTicks: params.nTicks
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useChunkSpreads(poolAddress, params, options) {
+	const { publicClient, chainId, clientScope, storageScope } = usePanopticContext();
+	const storage = useRequireStorage();
+	return useQuery({
+		queryKey: [
+			...queryKeys.chunkSpreads(chainId, poolAddress),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params.sfpmAddress,
+			getStorageCacheScopeKey(storage, storageScope)
+		],
+		queryFn: () => getChunkSpreads({
+			client: publicClient,
+			chainId,
+			poolAddress,
+			sfpmAddress: params.sfpmAddress,
+			storage
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePosition(poolAddress, owner, tokenId, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.position(chainId, poolAddress, tokenId),
+			getClientCacheScopeKey(publicClient, clientScope),
+			owner
+		],
+		queryFn: () => getPosition({
+			client: publicClient,
+			poolAddress,
+			owner,
+			tokenId
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePositions(poolAddress, tokenIds, owner, options) {
+	const ctx = usePanopticContext();
+	const resolvedOwner = owner ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.positions(ctx.chainId, poolAddress, resolvedOwner ?? ""),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds
+		],
+		queryFn: () => {
+			if (!resolvedOwner) throw new Error("owner required for getPositions");
+			return getPositions({
+				client: ctx.publicClient,
+				poolAddress,
+				owner: resolvedOwner,
+				tokenIds
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedOwner,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePositionGreeks(poolAddress, tokenId, owner, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.positionGreeks(chainId, poolAddress, tokenId),
+			getClientCacheScopeKey(publicClient, clientScope),
+			owner
+		],
+		queryFn: () => getPositionGreeks({
+			client: publicClient,
+			poolAddress,
+			tokenId,
+			owner
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useAccountCollateral(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.accountCollateral(ctx.chainId, poolAddress, resolvedAccount ?? ""), getClientCacheScopeKey(ctx.publicClient, ctx.clientScope)],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for getAccountCollateral");
+			return getAccountCollateral({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useInterestState(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.interestState(ctx.chainId, poolAddress, resolvedAccount ?? ""), getClientCacheScopeKey(ctx.publicClient, ctx.clientScope)],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for getInterestState");
+			return getInterestState({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useAccountSummaryBasic(poolAddress, tokenIds, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.accountSummaryBasic(ctx.chainId, poolAddress, resolvedAccount ?? ""),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds
+		],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for getAccountSummaryBasic");
+			return getAccountSummaryBasic({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount,
+				chainId: ctx.chainId,
+				tokenIds
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useAccountSummaryRisk(poolAddress, tokenIds, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.accountSummaryRisk(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress,
+			options?.atTick,
+			options?.includePendingPremium
+		],
+		queryFn: () => getAccountSummaryRisk({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			chainId: ctx.chainId,
+			tokenIds,
+			queryAddress,
+			atTick: options?.atTick,
+			includePendingPremium: options?.includePendingPremium
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useNetLiquidationValue(poolAddress, tokenIds, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"netLiquidationValue",
+			ctx.chainId.toString(),
+			poolAddress,
+			resolvedAccount,
+			getAtTickCacheKey(options?.atTick),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress
+		],
+		queryFn: () => getNetLiquidationValue({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds,
+			atTick: options?.atTick,
+			queryAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useNetLiquidationValues(poolAddress, tokenIds, queryAddress, atTicks, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"netLiquidationValues",
+			ctx.chainId.toString(),
+			poolAddress,
+			resolvedAccount,
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress,
+			atTicks
+		],
+		queryFn: () => getNetLiquidationValues({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds,
+			atTicks,
+			queryAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount && atTicks.length > 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useLiquidationPrices(poolAddress, tokenIds, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.liquidationPrices(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress
+		],
+		queryFn: () => getLiquidationPrices({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds,
+			queryAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useAccountGreeks(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.accountGreeks(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			getStorageCacheScopeKey(storage, ctx.storageScope)
+		],
+		queryFn: () => getAccountGreeks({
+			client: ctx.publicClient,
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useMarginBuffer(poolAddress, tokenIds, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.marginBuffer(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress
+		],
+		queryFn: () => getMarginBuffer({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds,
+			queryAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useIsLiquidatable(poolAddress, tokenIds, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.isLiquidatable(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds,
+			queryAddress
+		],
+		queryFn: () => isLiquidatable({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds,
+			queryAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useAccountPremia(poolAddress, tokenIds, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.accountPremia(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds
+		],
+		queryFn: () => getAccountPremia({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePositionsWithPremia(poolAddress, tokenIds, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.positionsWithPremia(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenIds
+		],
+		queryFn: () => getPositionsWithPremia({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenIds
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePreviewDeposit(poolAddress, tokenIndex, amount, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.erc4626Preview(chainId, poolAddress, "deposit", amount),
+			getClientCacheScopeKey(publicClient, clientScope),
+			tokenIndex
+		],
+		queryFn: () => previewDeposit({
+			client: publicClient,
+			poolAddress,
+			tokenIndex,
+			amount
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePreviewWithdraw(poolAddress, tokenIndex, amount, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.erc4626Preview(chainId, poolAddress, "withdraw", amount),
+			getClientCacheScopeKey(publicClient, clientScope),
+			tokenIndex
+		],
+		queryFn: () => previewWithdraw({
+			client: publicClient,
+			poolAddress,
+			tokenIndex,
+			amount
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePreviewMint(poolAddress, tokenIndex, amount, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.erc4626Preview(chainId, poolAddress, "mint", amount),
+			getClientCacheScopeKey(publicClient, clientScope),
+			tokenIndex
+		],
+		queryFn: () => previewMint({
+			client: publicClient,
+			poolAddress,
+			tokenIndex,
+			amount
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePreviewRedeem(poolAddress, tokenIndex, amount, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.erc4626Preview(chainId, poolAddress, "redeem", amount),
+			getClientCacheScopeKey(publicClient, clientScope),
+			tokenIndex
+		],
+		queryFn: () => previewRedeem({
+			client: publicClient,
+			poolAddress,
+			tokenIndex,
+			amount
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useEstimateCollateralRequired(poolAddress, tokenId, positionSize, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.collateralEstimate(ctx.chainId, poolAddress, resolvedAccount, tokenId),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			positionSize,
+			queryAddress,
+			options?.atTick
+		],
+		queryFn: () => estimateCollateralRequired({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			tokenId,
+			positionSize,
+			queryAddress,
+			atTick: options?.atTick
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useFlowNeutralTokenId(poolAddress, tokenId, positionSize, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	const neutralizeITM = options?.neutralizeITM ?? true;
+	const swapAtMint = options?.swapAtMint ?? true;
+	const referenceSize = options?.referenceSize;
+	const queryAddress = options?.queryAddress;
+	return useQuery({
+		queryKey: [
+			...queryKeys.flowNeutralTokenId(ctx.chainId, poolAddress, tokenId),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			resolvedAccount ?? "",
+			positionSize.toString(),
+			(options?.existingPositionIds ?? []).map(String).join(","),
+			neutralizeITM,
+			swapAtMint,
+			positionSize,
+			options?.existingPositionIds,
+			(referenceSize ?? 0n).toString(),
+			referenceSize,
+			queryAddress ?? ""
+		],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for createFlowNeutralTokenId");
+			return createFlowNeutralTokenId({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount,
+				tokenId,
+				positionSize,
+				existingPositionIds: options?.existingPositionIds,
+				swapAtMint,
+				referenceSize,
+				queryAddress
+			});
+		},
+		enabled: (options?.enabled ?? true) && neutralizeITM && !!resolvedAccount && tokenId !== 0n && positionSize > 0n,
+		refetchInterval: options?.refetchInterval
+	});
+}
+function useMaxPositionSize(poolAddress, tokenId, queryAddress, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.maxPositionSize(ctx.chainId, poolAddress, resolvedAccount ?? "", tokenId),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			queryAddress,
+			options?.existingPositionIds?.map(String).join(",") ?? "",
+			options?.existingPositionIds,
+			options?.swapAtMint ?? false,
+			options?.precisionPct ?? 1,
+			options?.usePremiaAsCollateral ?? false
+		],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for getMaxPositionSize");
+			return getMaxPositionSize({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount,
+				tokenId,
+				queryAddress,
+				existingPositionIds: options?.existingPositionIds,
+				swapAtMint: options?.swapAtMint,
+				precisionPct: options?.precisionPct,
+				usePremiaAsCollateral: options?.usePremiaAsCollateral
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		placeholderData: keepPreviousData
+	});
+}
+function useOptimizeRiskPartners(poolAddress, tokenId, queryAddress, atTick, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.optimizeRiskPartners(chainId, poolAddress, tokenId),
+			getClientCacheScopeKey(publicClient, clientScope),
+			queryAddress,
+			getAtTickCacheKey(atTick)
+		],
+		queryFn: () => optimizeTokenIdRiskPartners({
+			client: publicClient,
+			poolAddress,
+			tokenId,
+			queryAddress,
+			atTick
+		}),
+		enabled: options?.enabled,
+		refetchInterval: options?.refetchInterval,
+		placeholderData: keepPreviousData
+	});
+}
+function useMaxWithdrawable(collateralTrackerAddress, positionIdList, totalAssets, account, options) {
+	const ctx = usePanopticContext();
+	const client = options?.client ?? ctx.publicClient;
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.maxWithdrawable(ctx.chainId, collateralTrackerAddress, positionIdList, totalAssets, resolvedAccount ?? ""), getClientCacheScopeKey(client, ctx.clientScope)],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for getMaxWithdrawable");
+			return getMaxWithdrawable({
+				client,
+				collateralTrackerAddress,
+				account: resolvedAccount,
+				positionIdList,
+				totalAssets
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!resolvedAccount && totalAssets > 0n,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useOpenPositionPreview(poolAddress, account, existingPositionIds, tokenId, positionSize, queryAddress, tickLimitLow, tickLimitHigh, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"openPositionPreview",
+			ctx.chainId.toString(),
+			poolAddress,
+			resolvedAccount,
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			tokenId.toString(),
+			positionSize.toString(),
+			existingPositionIds.map(String).join(","),
+			queryAddress,
+			tickLimitLow.toString(),
+			tickLimitHigh.toString(),
+			options?.spreadLimit?.toString(),
+			options?.swapAtMint,
+			options?.usePremiaAsCollateral,
+			options?.blockNumber?.toString()
+		],
+		queryFn: () => getOpenPositionPreview({
+			client: ctx.publicClient,
+			poolAddress,
+			account: resolvedAccount,
+			existingPositionIds,
+			tokenId,
+			positionSize,
+			queryAddress,
+			tickLimitLow,
+			tickLimitHigh,
+			spreadLimit: options?.spreadLimit,
+			swapAtMint: options?.swapAtMint,
+			usePremiaAsCollateral: options?.usePremiaAsCollateral,
+			chainId: ctx.chainId,
+			blockNumber: options?.blockNumber
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount && tokenId !== 0n,
+		staleTime: options?.staleTime ?? 0
+	});
+}
+function useTrackedPositionIds(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.trackedPositionIds(ctx.chainId, poolAddress, resolvedAccount), getStorageCacheScopeKey(storage, ctx.storageScope)],
+		queryFn: () => getTrackedPositionIds({
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useTradeHistory(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.tradeHistory(ctx.chainId, poolAddress, resolvedAccount), getStorageCacheScopeKey(storage, ctx.storageScope)],
+		queryFn: () => getTradeHistory({
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useRealizedPnL(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.realizedPnL(ctx.chainId, poolAddress, resolvedAccount), getStorageCacheScopeKey(storage, ctx.storageScope)],
+		queryFn: () => getRealizedPnL({
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useClosedPositions(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [...queryKeys.closedPositions(ctx.chainId, poolAddress, resolvedAccount), getStorageCacheScopeKey(storage, ctx.storageScope)],
+		queryFn: () => getClosedPositions({
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useSyncStatus(poolAddress, account, options) {
+	const ctx = usePanopticContext();
+	const storage = useRequireStorage();
+	const resolvedAccount = account ?? ctx.account;
+	return useQuery({
+		queryKey: [
+			...queryKeys.syncStatus(ctx.chainId, poolAddress, resolvedAccount),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			getStorageCacheScopeKey(storage, ctx.storageScope)
+		],
+		queryFn: () => getSyncStatus({
+			client: ctx.publicClient,
+			chainId: ctx.chainId,
+			poolAddress,
+			account: resolvedAccount,
+			storage
+		}),
+		enabled: (options?.enabled ?? true) && !!resolvedAccount,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePanopticPoolAddress(params, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"factory",
+			"getPanopticPool",
+			params?.factoryAddress,
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new PanopticValidationError("params is required");
+			return getPanopticPoolAddress({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: (options?.enabled ?? true) && params !== void 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useFactoryTokenURI(params, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"factory",
+			"tokenURI",
+			params?.factoryAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new PanopticValidationError("params is required");
+			return getFactoryTokenURI({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: (options?.enabled ?? true) && params !== void 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useFactoryOwnerOf(params, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"factory",
+			"ownerOf",
+			params?.factoryAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new PanopticValidationError("params is required");
+			return getFactoryOwnerOf({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: (options?.enabled ?? true) && params !== void 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useMinePoolAddress() {
+	return useMutation({ mutationFn: (params) => minePoolAddressLocalAsync(params) });
+}
+function useFactoryConstructMetadata(params, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"factory",
+			"constructMetadata",
+			params?.factoryAddress,
+			params?.panopticPoolAddress,
+			params?.symbol0,
+			params?.symbol1,
+			params?.fee?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new PanopticValidationError("params is required");
+			return getFactoryConstructMetadata({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: (options?.enabled ?? true) && params !== void 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useSimulateDeployNewPool(params, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"factory",
+			"simulateDeployNewPool",
+			params?.factoryAddress,
+			params?.account,
+			params?.salt?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new PanopticValidationError("params is required");
+			return simulateDeployNewPool({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: (options?.enabled ?? true) && params !== void 0,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* Build a stable string cache key from time range params (no object references).
+*/
+function buildRangeHash(timeRange) {
+	const pinnedSuffix = timeRange.pinnedBlocks?.length ? `-pin:${timeRange.pinnedBlocks.join(",")}` : "";
+	return timeRange.mode === "timestamps" ? `ts:${timeRange.startTimestamp}-${timeRange.endTimestamp ?? "now"}-${timeRange.points}-${timeRange.resolution ?? "exact"}${pinnedSuffix}` : `blk:${timeRange.startBlock}-${timeRange.endBlock ?? "latest"}-${timeRange.points}${pinnedSuffix}`;
+}
+/**
+* Resolve a PriceHistoryTimeRange to start/end block numbers.
+*/
+async function resolveTimeRange(client, timeRange) {
+	if (timeRange.mode === "timestamps") {
+		const resolver = timeRange.resolution === "estimate" ? estimateBlockNumbers : resolveBlockNumbers;
+		if (timeRange.endTimestamp !== void 0) {
+			const resolved = await resolver({
+				client,
+				timestamps: [timeRange.startTimestamp, timeRange.endTimestamp]
+			});
+			return {
+				startBlock: resolved[0],
+				endBlock: resolved[1]
+			};
+		} else {
+			const [resolved, latest] = await Promise.all([resolver({
+				client,
+				timestamps: [timeRange.startTimestamp]
+			}), client.getBlockNumber()]);
+			return {
+				startBlock: resolved[0],
+				endBlock: latest
+			};
+		}
+	} else return {
+		startBlock: timeRange.startBlock,
+		endBlock: timeRange.endBlock ?? await client.getBlockNumber()
+	};
+}
+/**
+* Hook to fetch historical price data (tick + sqrtPriceX96) for a pool.
+*
+* Supports two modes:
+* - **timestamps**: Resolves start/end timestamps to blocks (2 RPC binary searches),
+*   then interpolates the blocks in between (pure math).
+* - **blocks**: Uses start/end blocks directly, interpolates in between.
+*   Zero resolution overhead.
+*
+* In both cases, the actual price reads are O(points) slot0 calls.
+* Reads at different historical blocks cannot be coalesced into one multicall.
+*
+* @param poolConfig - Pool version config (V3 pool address or V4 StateView + poolId)
+* @param timeRange - Time range specification (timestamps or blocks)
+* @param options - Query options (enabled, refetchInterval, staleTime, gcTime)
+*/
+function usePriceHistory(poolConfig, timeRange, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	const poolKey = poolConfig.version === "v3" ? poolConfig.poolAddress : poolConfig.poolId;
+	const rangeHash = buildRangeHash(timeRange);
+	return useQuery({
+		queryKey: [...queryKeys.priceHistory(chainId, poolKey, rangeHash), getClientCacheScopeKey(publicClient, clientScope)],
+		queryFn: async () => {
+			const { startBlock, endBlock } = await resolveTimeRange(publicClient, timeRange);
+			let blockNumbers = interpolateBlocks(startBlock, endBlock, timeRange.points);
+			if (timeRange.pinnedBlocks?.length) {
+				const blockSet = new Set(blockNumbers.map(String));
+				const extras = timeRange.pinnedBlocks.filter((b) => b >= startBlock && b <= endBlock && !blockSet.has(String(b)));
+				if (extras.length > 0) blockNumbers = [...blockNumbers, ...extras].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+			}
+			return getPriceHistory({
+				client: publicClient,
+				blockNumbers,
+				poolConfig
+			});
+		},
+		enabled: (options?.enabled ?? true) && timeRange.points > 0,
+		staleTime: options?.staleTime ?? Infinity,
+		gcTime: options?.gcTime ?? 60 * 6e4,
+		refetchInterval: options?.refetchInterval ?? false,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false
+	});
+}
+/**
+* Hook to fetch historical streamia (streaming premia + Uniswap fee) data for a position.
+*
+* @param panopticPoolAddress - PanopticPool contract address
+* @param account - Account whose position to query
+* @param tokenId - The encoded tokenId
+* @param legs - Decoded legs with pre-computed liquidity
+* @param poolConfig - Pool version config (V3 pool address or V4 StateView + poolId)
+* @param timeRange - Time range specification (timestamps or blocks)
+* @param options - Query options + optional includeUniswapFees and settledEvents
+*/
+function useStreamiaHistory(panopticPoolAddress, account, tokenId, legs, poolConfig, timeRange, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	const poolKey = poolConfig.version === "v3" ? poolConfig.poolAddress : poolConfig.poolId;
+	const rangeHash = buildRangeHash(timeRange);
+	const legsKey = legs.map((l) => `${l.lowerTick}:${l.upperTick}:${l.liquidity}`).join(",");
+	const includeUniswapFees = options?.includeUniswapFees ?? true;
+	const settledEventsKey = options?.settledEvents ? options.settledEvents.map((e) => `${e.blockNumber}:${e.settled0}:${e.settled1}`).join(",") : "";
+	return useQuery({
+		queryKey: [
+			...queryKeys.streamiaHistory(chainId, poolKey, rangeHash),
+			getClientCacheScopeKey(publicClient, clientScope),
+			panopticPoolAddress,
+			account,
+			tokenId.toString(),
+			legsKey,
+			includeUniswapFees,
+			settledEventsKey
+		],
+		queryFn: async () => {
+			const { startBlock, endBlock } = await resolveTimeRange(publicClient, timeRange);
+			let blockNumbers = interpolateBlocks(startBlock, endBlock, timeRange.points);
+			if (timeRange.pinnedBlocks?.length) {
+				const pinSet = new Set(blockNumbers.map(String));
+				const pins = timeRange.pinnedBlocks.filter((b) => b >= startBlock && b <= endBlock && !pinSet.has(String(b)));
+				if (pins.length) blockNumbers = [...blockNumbers, ...pins].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+			}
+			return getStreamiaHistory({
+				client: publicClient,
+				panopticPoolAddress,
+				account,
+				tokenId,
+				blockNumbers,
+				legs,
+				poolConfig,
+				includeUniswapFees: options?.includeUniswapFees,
+				settledEvents: options?.settledEvents
+			});
+		},
+		enabled: (options?.enabled ?? true) && timeRange.points > 0,
+		staleTime: options?.staleTime ?? Infinity,
+		gcTime: options?.gcTime ?? 60 * 6e4,
+		refetchInterval: options?.refetchInterval ?? false,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false
+	});
+}
+/**
+* Hook to fetch historical Uniswap fee data for a set of liquidity legs.
+*
+* @param legs - Decoded legs with pre-computed liquidity
+* @param poolConfig - Pool version config (V3 pool address or V4 StateView + poolId)
+* @param timeRange - Time range specification (timestamps or blocks)
+* @param options - Query options (enabled, refetchInterval, staleTime, gcTime)
+*/
+function useUniswapFeeHistory(legs, poolConfig, timeRange, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	const poolKey = poolConfig.version === "v3" ? poolConfig.poolAddress : poolConfig.poolId;
+	const rangeHash = buildRangeHash(timeRange);
+	const legsKey = legs.map((l) => `${l.lowerTick}:${l.upperTick}:${l.liquidity}`).join(",");
+	return useQuery({
+		queryKey: [
+			...queryKeys.uniswapFeeHistory(chainId, poolKey, rangeHash),
+			getClientCacheScopeKey(publicClient, clientScope),
+			legsKey
+		],
+		queryFn: async () => {
+			const { startBlock, endBlock } = await resolveTimeRange(publicClient, timeRange);
+			let blockNumbers = interpolateBlocks(startBlock, endBlock, timeRange.points);
+			if (timeRange.pinnedBlocks?.length) {
+				const pinSet = new Set(blockNumbers.map(String));
+				const pins = timeRange.pinnedBlocks.filter((b) => b >= startBlock && b <= endBlock && !pinSet.has(String(b)));
+				if (pins.length) blockNumbers = [...blockNumbers, ...pins].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+			}
+			return getUniswapFeeHistory({
+				client: publicClient,
+				blockNumbers,
+				legs,
+				poolConfig
+			});
+		},
+		enabled: (options?.enabled ?? true) && timeRange.points > 0 && legs.length > 0,
+		staleTime: options?.staleTime ?? Infinity,
+		gcTime: options?.gcTime ?? 60 * 6e4,
+		refetchInterval: options?.refetchInterval ?? false,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false
+	});
+}
+/**
+* Reads basic on-chain info (token0, token1, fee, tickSpacing, slot0, liquidity) from a Uniswap V3 pool.
+* @param poolAddress - The Uniswap V3 pool contract address.
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to the pool info object.
+*/
+function useUniswapV3PoolInfo(poolAddress, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV3PoolInfo",
+			chainId.toString(),
+			poolAddress,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => getUniswapV3PoolInfo({
+			client: publicClient,
+			poolAddress
+		}),
+		enabled: (options?.enabled ?? true) && !!poolAddress,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* Reads per-tick active liquidity from a Uniswap V3 pool via PanopticQuery's `getTickNetsV3`.
+* @param poolAddress - The Uniswap V3 pool contract address.
+* @param queryAddress - The PanopticQuery helper contract address.
+* @param args - Tick window: `startTick` (inclusive) and `nTicks` count to scan.
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to `{ ticks, liquidityNets }` parallel arrays.
+*/
+function useUniswapV3PoolLiquidities(poolAddress, queryAddress, args, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV3PoolLiquidities",
+			chainId.toString(),
+			poolAddress,
+			queryAddress,
+			args?.startTick,
+			args?.nTicks,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => {
+			if (!poolAddress || !queryAddress || !args) throw new PanopticValidationError("useUniswapV3PoolLiquidities: missing required args");
+			const { startTick, nTicks } = args;
+			return getUniswapV3PoolLiquidities({
+				client: publicClient,
+				poolAddress,
+				queryAddress,
+				startTick,
+				nTicks
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!poolAddress && !!queryAddress && !!args,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* Resolves a Uniswap V4 PoolKey from a poolId hash by scanning `Initialize` event logs on the PoolManager.
+* PoolKey is immutable, so results are cached indefinitely within the session by default.
+* @param poolManager - The Uniswap V4 PoolManager contract address.
+* @param poolId - The 32-byte poolId hash.
+* @param args - Optional `fromBlock` and `chunkSize` for log paging.
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to the resolved `UniswapV4PoolKey`.
+*/
+function useResolveUniswapV4PoolKey(poolManager, poolId, args, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV4PoolKey",
+			chainId.toString(),
+			poolManager,
+			poolId,
+			args?.fromBlock?.toString(),
+			args?.chunkSize?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => resolveUniswapV4PoolKey({
+			client: publicClient,
+			poolManager,
+			poolId,
+			fromBlock: args?.fromBlock,
+			chunkSize: args?.chunkSize
+		}),
+		enabled: (options?.enabled ?? true) && !!poolManager && !!poolId,
+		staleTime: options?.staleTime ?? Infinity,
+		gcTime: options?.gcTime,
+		refetchInterval: options?.refetchInterval
+	});
+}
+/**
+* Reads basic on-chain state (slot0, liquidity) for a Uniswap V4 pool via the StateView contract.
+* @param stateViewAddress - The Uniswap V4 StateView contract address.
+* @param poolId - The 32-byte poolId hash.
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to the pool's basic state.
+*/
+function useUniswapV4PoolBasicState(stateViewAddress, poolId, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV4PoolBasicState",
+			chainId.toString(),
+			stateViewAddress,
+			poolId,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => getUniswapV4PoolBasicState({
+			client: publicClient,
+			stateViewAddress,
+			poolId
+		}),
+		enabled: (options?.enabled ?? true) && !!stateViewAddress && !!poolId,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* Reads full pool info (slot0, liquidity, and PoolKey-derived metadata) for a Uniswap V4 pool via the StateView contract.
+* @param stateViewAddress - The Uniswap V4 StateView contract address.
+* @param poolKey - The pool's `UniswapV4PoolKey` (currency0, currency1, fee, tickSpacing, hooks).
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to the full pool info object.
+*/
+function useUniswapV4PoolInfo(stateViewAddress, poolKey, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV4PoolInfo",
+			chainId.toString(),
+			stateViewAddress,
+			poolKey?.currency0,
+			poolKey?.currency1,
+			poolKey?.fee,
+			poolKey?.tickSpacing,
+			poolKey?.hooks,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => getUniswapV4PoolInfo({
+			client: publicClient,
+			stateViewAddress,
+			poolKey
+		}),
+		enabled: (options?.enabled ?? true) && !!stateViewAddress && !!poolKey,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+/**
+* Reads per-tick active liquidity from a Uniswap V4 pool via PanopticQuery's `getTickNetsV4`.
+* @param queryAddress - The PanopticQuery helper contract address.
+* @param poolManager - The Uniswap V4 PoolManager contract address.
+* @param poolId - The 32-byte poolId hash.
+* @param args - `tickSpacing`, `startTick` (inclusive), and `nTicks` count to scan.
+* @param options - Optional React Query options (`enabled`, `staleTime`, `gcTime`, `refetchInterval`).
+* @returns React Query result resolving to `{ ticks, liquidityNets }` parallel arrays.
+*/
+function useUniswapV4PoolLiquidities(queryAddress, poolManager, poolId, args, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapV4PoolLiquidities",
+			chainId.toString(),
+			queryAddress,
+			poolManager,
+			poolId,
+			args?.tickSpacing,
+			args?.startTick,
+			args?.nTicks,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => {
+			if (!queryAddress || !poolManager || !poolId || !args) throw new PanopticValidationError("useUniswapV4PoolLiquidities: missing required args");
+			const { tickSpacing, startTick, nTicks } = args;
+			return getUniswapV4PoolLiquidities({
+				client: publicClient,
+				queryAddress,
+				poolManager,
+				poolId,
+				tickSpacing,
+				startTick,
+				nTicks
+			});
+		},
+		enabled: (options?.enabled ?? true) && !!queryAddress && !!poolManager && !!poolId && !!args,
+		refetchInterval: options?.refetchInterval,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function useNativeTokenPrice(panopticPoolAddress, token0Decimals, token1Decimals, nativeIsToken0, options) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"nativeTokenPrice",
+			chainId,
+			panopticPoolAddress,
+			token0Decimals,
+			token1Decimals,
+			nativeIsToken0,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => getNativeTokenPrice({
+			client: publicClient,
+			panopticPoolAddress,
+			token0Decimals,
+			token1Decimals,
+			nativeIsToken0
+		}),
+		enabled: (options?.enabled ?? true) && panopticPoolAddress !== void 0,
+		refetchInterval: options?.refetchInterval ?? 3e4,
+		staleTime: options?.staleTime,
+		gcTime: options?.gcTime
+	});
+}
+function usePreviewBorrow(poolAddress, params, options) {
+	const ctx = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"previewBorrow",
+			ctx.chainId,
+			poolAddress,
+			params?.account,
+			params?.token,
+			params?.amount?.toString(),
+			params?.slippageBps?.toString(),
+			params?.existingPositionIds?.map(String).join(","),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope)
+		],
+		queryFn: () => previewBorrow({
+			client: ctx.publicClient,
+			poolAddress,
+			chainId: ctx.chainId,
+			account: params.account,
+			token: params.token,
+			amount: params.amount,
+			slippageBps: params.slippageBps,
+			existingPositionIds: params.existingPositionIds
+		}),
+		enabled: (options?.enabled ?? true) && !!params && params.amount > 0n,
+		staleTime: options?.staleTime ?? 1e4,
+		gcTime: options?.gcTime,
+		placeholderData: keepPreviousData
+	});
+}
+/**
+* Validate whether a builder code maps to a deployed builder wallet.
+*
+* Returns `{ data: true }` for valid codes, `{ data: false }` for invalid.
+* Disabled when `builderCode` is `undefined` or `0n`.
+*/
+function useValidateBuilderCode(poolAddress, builderCode, options) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			"validateBuilderCode",
+			poolAddress,
+			String(builderCode),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => {
+			if (builderCode === void 0) throw new Error("builderCode is undefined");
+			return validateBuilderCode({
+				client: publicClient,
+				poolAddress,
+				builderCode
+			});
+		},
+		enabled: (options?.enabled ?? true) && builderCode !== void 0 && builderCode !== 0n,
+		staleTime: options?.staleTime ?? 6e4,
+		gcTime: options?.gcTime
+	});
+}
+
+//#endregion
+//#region src/panoptic/v2/react/mutationEffects.ts
+/**
+* Returns query keys that should be invalidated after a mutation.
+*
+* Use with TanStack Query's `queryClient.invalidateQueries()` or SWR's `mutate()`.
+*
+* @example
+* ```typescript
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+* import { mutationEffects, openPosition } from 'panoptic-v2-sdk'
+*
+* function useOpenPosition(config: WriteConfig) {
+*   const queryClient = useQueryClient()
+*
+*   return useMutation({
+*     mutationFn: (params) => openPosition(config, params),
+*     onSuccess: () => {
+*       const keysToInvalidate = mutationEffects.openPosition({
+*         chainId: config.chainId,
+*         poolAddress: config.poolAddress,
+*         account: config.walletClient.account.address,
+*       })
+*
+*       for (const key of keysToInvalidate) {
+*         queryClient.invalidateQueries({ queryKey: key })
+*       }
+*     },
+*   })
+* }
+* ```
+*/
+const mutationEffects = {
+	openPosition: (params) => {
+		const { chainId, poolAddress, account } = params;
+		return [
+			queryKeys.pool(chainId, poolAddress),
+			queryKeys.utilization(chainId, poolAddress),
+			queryKeys.positions(chainId, poolAddress, account),
+			queryKeys.trackedPositionIds(chainId, poolAddress, account),
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.isLiquidatable(chainId, poolAddress, account),
+			queryKeys.liquidationPrices(chainId, poolAddress, account),
+			queryKeys.accountGreeks(chainId, poolAddress, account),
+			queryKeys.chunkSpreads(chainId, poolAddress)
+		];
+	},
+	closePosition: (params) => {
+		const { chainId, poolAddress, account, tokenId } = params;
+		const keys = [
+			queryKeys.pool(chainId, poolAddress),
+			queryKeys.utilization(chainId, poolAddress),
+			queryKeys.positions(chainId, poolAddress, account),
+			queryKeys.trackedPositionIds(chainId, poolAddress, account),
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.isLiquidatable(chainId, poolAddress, account),
+			queryKeys.liquidationPrices(chainId, poolAddress, account),
+			queryKeys.accountGreeks(chainId, poolAddress, account),
+			queryKeys.closedPositions(chainId, poolAddress, account),
+			queryKeys.tradeHistory(chainId, poolAddress, account),
+			queryKeys.realizedPnL(chainId, poolAddress, account),
+			queryKeys.chunkSpreads(chainId, poolAddress)
+		];
+		if (tokenId !== void 0) {
+			keys.push(queryKeys.position(chainId, poolAddress, tokenId));
+			keys.push(queryKeys.positionGreeks(chainId, poolAddress, tokenId));
+		}
+		return keys;
+	},
+	forceExercise: (params) => {
+		const { chainId, poolAddress, account, tokenId } = params;
+		const keys = [
+			queryKeys.pool(chainId, poolAddress),
+			queryKeys.utilization(chainId, poolAddress),
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.chunkSpreads(chainId, poolAddress)
+		];
+		if (tokenId !== void 0) keys.push(queryKeys.position(chainId, poolAddress, tokenId));
+		return keys;
+	},
+	liquidate: (params) => {
+		const { chainId, poolAddress, account } = params;
+		return [
+			queryKeys.pool(chainId, poolAddress),
+			queryKeys.utilization(chainId, poolAddress),
+			queryKeys.positions(chainId, poolAddress, account),
+			queryKeys.trackedPositionIds(chainId, poolAddress, account),
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.isLiquidatable(chainId, poolAddress, account),
+			queryKeys.liquidationPrices(chainId, poolAddress, account),
+			queryKeys.accountGreeks(chainId, poolAddress, account),
+			queryKeys.closedPositions(chainId, poolAddress, account),
+			queryKeys.chunkSpreads(chainId, poolAddress)
+		];
+	},
+	settleAccumulatedPremia: (params) => {
+		const { chainId, poolAddress, account, tokenId } = params;
+		const keys = [
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account)
+		];
+		if (tokenId !== void 0) keys.push(queryKeys.position(chainId, poolAddress, tokenId));
+		return keys;
+	},
+	deposit: (params) => {
+		const { chainId, poolAddress, account } = params;
+		return [
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.isLiquidatable(chainId, poolAddress, account),
+			queryKeys.liquidationPrices(chainId, poolAddress, account)
+		];
+	},
+	withdraw: (params) => {
+		const { chainId, poolAddress, account } = params;
+		return [
+			queryKeys.accountCollateral(chainId, poolAddress, account),
+			queryKeys.accountSummaryBasic(chainId, poolAddress, account),
+			queryKeys.accountSummaryRisk(chainId, poolAddress, account),
+			queryKeys.isLiquidatable(chainId, poolAddress, account),
+			queryKeys.liquidationPrices(chainId, poolAddress, account)
+		];
+	},
+	mint: (params) => {
+		return mutationEffects.deposit(params);
+	},
+	redeem: (params) => {
+		return mutationEffects.withdraw(params);
+	},
+	approve: (chainId, token, owner, spender) => {
+		return [queryKeys.approval(chainId, token, owner, spender)];
+	},
+	pokeOracle: (params) => {
+		const { chainId, poolAddress } = params;
+		return [queryKeys.oracle(chainId, poolAddress), queryKeys.safeMode(chainId, poolAddress)];
+	}
+};
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/writes.ts
+function requireWallet$2(inputs) {
+	if (!inputs.walletClient || !inputs.account) throw new Error("walletClient and account are required. Provide them via PanopticProvider.");
+	return {
+		walletClient: inputs.walletClient,
+		account: inputs.account
+	};
+}
+function createWalletMutationContext(inputs) {
+	return { signerAccount: requireWallet$2(inputs).account };
+}
+function invalidateKeys(queryClient, keysToInvalidate) {
+	const seen = new Set();
+	for (const key of keysToInvalidate) {
+		const serialized = JSON.stringify(key);
+		if (seen.has(serialized)) continue;
+		seen.add(serialized);
+		queryClient.invalidateQueries({ queryKey: key });
+	}
+}
+function useApprove() {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return approve({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.approve(chainId, params.tokenAddress, context.signerAccount, params.spenderAddress));
+		}
+	});
+}
+function useApprovePool(poolAddress) {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return approvePool({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all, "approval"] });
+		}
+	});
+}
+function useDeposit(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return deposit({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useWithdraw(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return withdraw({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.withdraw({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+/**
+* Wrap an underlying xStock into its ERC4626 wrapper (`deposit`). Requires a
+* prior approval of the underlying to the wrapper (use {@link useApprove}).
+* Invalidates SDK queries so balances refetch.
+*/
+function useWrapXstock() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return wrapXstock({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all] });
+		}
+	});
+}
+/**
+* Unwrap wrapper shares back into the underlying xStock (`redeem`). Burns the
+* owner's own shares — no approval needed.
+*/
+function useUnwrapXstock() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return unwrapXstock({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all] });
+		}
+	});
+}
+/**
+* Wrap native ETH into WETH (`deposit` payable). No approval needed.
+* Invalidates SDK queries so balances refetch.
+*/
+function useWrapEth() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return wrapEth({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all] });
+		}
+	});
+}
+/**
+* Unwrap WETH back into native ETH (`withdraw`). Burns the caller's own WETH —
+* no approval needed. Invalidates SDK queries so balances refetch.
+*/
+function useUnwrapWeth() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return unwrapWeth({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all] });
+		}
+	});
+}
+function useMintShares(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return mint({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.mint({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useRedeem(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return redeem({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.redeem({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useWithdrawWithPositions(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return withdrawWithPositions({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.withdraw({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useOpenPosition(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return openPosition({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.openPosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useClosePosition(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return closePosition({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.closePosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount,
+				tokenId: params.tokenId
+			}));
+		}
+	});
+}
+function useRollPosition(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return rollPosition({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.openPosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useLiquidate(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return liquidate({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, [...mutationEffects.liquidate({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}), ...mutationEffects.liquidate({
+				chainId,
+				poolAddress,
+				account: params.liquidatee
+			})]);
+		}
+	});
+}
+function useForceExercise(poolAddress) {
+	const { publicClient, chainId, walletClient, account, storage } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return forceExerciseAndWait({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params,
+				storage,
+				chainId
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, [...mutationEffects.forceExercise({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}), ...mutationEffects.forceExercise({
+				chainId,
+				poolAddress,
+				account: params.user
+			})]);
+		}
+	});
+}
+function useSettleAccumulatedPremia(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return settleAccumulatedPremia({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.settleAccumulatedPremia({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function usePokeOracle(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return pokeOracle({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: () => {
+			invalidateKeys(queryClient, mutationEffects.pokeOracle({
+				chainId,
+				poolAddress
+			}));
+		}
+	});
+}
+function useDispatch(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return dispatch({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.openPosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useBatchDispatch(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return executeBatchDispatch({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				...params
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			const closedTokenIds = params.items.filter((i) => i.kind === "burn").map((i) => i.tokenId);
+			const keys = [...mutationEffects.openPosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}), ...closedTokenIds.flatMap((tokenId) => mutationEffects.closePosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount,
+				tokenId
+			}))];
+			invalidateKeys(queryClient, keys);
+		}
+	});
+}
+function useDeployNewPool() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return deployNewPool({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [...queryKeys.all, "factory"] });
+		}
+	});
+}
+function useSwapExactOut(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return swapExactOut({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useSupply(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return supply({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useUnsupply(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return unsupply({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.withdraw({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useBorrow(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return borrow({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.openPosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useRepay(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return repay({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.closePosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount,
+				tokenId: params.loanTokenId
+			}));
+		}
+	});
+}
+function useSmartRepay(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return smartRepay({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.closePosition({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+function useSwapExactIn(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		onMutate: () => createWalletMutationContext({
+			walletClient,
+			account
+		}),
+		mutationFn: (params) => {
+			const wallet = requireWallet$2({
+				walletClient,
+				account
+			});
+			return swapExactIn({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: (_data, _params, context) => {
+			if (!context) return;
+			invalidateKeys(queryClient, mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account: context.signerAccount
+			}));
+		}
+	});
+}
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/simulations.ts
+function useSimulateOpenPosition(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"openPosition",
+			poolAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateOpenPosition({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateClosePosition(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"closePosition",
+			poolAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateClosePosition({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateDeposit(params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"deposit",
+			params?.collateralTrackerAddress,
+			params?.assets?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateDeposit({
+			client: publicClient,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateWithdraw(params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"withdraw",
+			params?.collateralTrackerAddress,
+			params?.assets?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateWithdraw({
+			client: publicClient,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateLiquidate(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"liquidate",
+			poolAddress,
+			params?.liquidatee,
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateLiquidate({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateForceExercise(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"forceExercise",
+			poolAddress,
+			params?.user,
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateForceExercise({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateSettle(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"settle",
+			poolAddress,
+			params?.account,
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateSettle({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateBatchDispatch(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"batchDispatch",
+			poolAddress,
+			params?.account,
+			params?.items?.length,
+			JSON.stringify(params?.items?.map((i) => `${i.kind}:${i.tokenId.toString()}`)),
+			JSON.stringify(params?.existingPositionIds?.map(String)),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateBatchDispatch({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0 && params.items !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateDispatch(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"dispatch",
+			poolAddress,
+			JSON.stringify(params?.positionIdList?.map(String)),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateDispatch({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateSFPMMint(params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"sfpmMint",
+			params?.sfpmAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new Error("params required for simulateSFPMMint");
+			return simulateSFPMMint({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateSFPMBurn(params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"sfpmBurn",
+			params?.sfpmAddress,
+			params?.tokenId?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => {
+			if (!params) throw new Error("params required for simulateSFPMBurn");
+			return simulateSFPMBurn({
+				client: publicClient,
+				...params
+			});
+		},
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateSwapExactOut(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"swapExactOut",
+			poolAddress,
+			params?.tokenOut,
+			params?.amountOut?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateSwapExactOut({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+function useSimulateSwapExactIn(poolAddress, params) {
+	const { publicClient, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"sim",
+			"swapExactIn",
+			poolAddress,
+			params?.tokenIn,
+			params?.amountIn?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope),
+			params
+		],
+		queryFn: () => simulateSwapExactIn({
+			client: publicClient,
+			poolAddress,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/uniswapRouter.ts
+function requireWallet$1(walletClient, account) {
+	if (!walletClient || !account) throw new PanopticError("walletClient and account are required. Provide them via PanopticProvider.");
+	return {
+		walletClient,
+		account
+	};
+}
+/**
+* Quote an exact-in spot swap via the Universal Router (V4Quoter-backed).
+* Returns a `SimulationResult`, matching `useSimulateSwapExactIn`'s shape.
+*/
+function useQuoteSwapExactInViaRouter(poolAddress, params) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapRouter",
+			"quote",
+			chainId,
+			poolAddress,
+			params?.tokenIn,
+			params?.amountIn?.toString(),
+			params?.slippageBps?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => quoteSwapExactInViaRouter({
+			client: publicClient,
+			poolAddress,
+			chainId,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+/**
+* Quote an exact-out spot swap via the Universal Router (V4Quoter-backed).
+* Returns a `SimulationResult` carrying the required input + `amountInMaximum`.
+*/
+function useQuoteSwapExactOutViaRouter(poolAddress, params) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapRouter",
+			"quoteExactOut",
+			chainId,
+			poolAddress,
+			params?.tokenIn,
+			params?.amountOut?.toString(),
+			params?.slippageBps?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => quoteSwapExactOutViaRouter({
+			client: publicClient,
+			poolAddress,
+			chainId,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+/**
+* Check the ERC20 → Permit2 → Universal Router allowance chain.
+*/
+function useCheckRouterApproval(params) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"uniswapRouter",
+			"approval",
+			chainId,
+			params?.tokenIn,
+			params?.owner,
+			params?.amount?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => checkRouterApproval({
+			client: publicClient,
+			chainId,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+/**
+* Execute an exact-in spot swap via the Universal Router.
+*/
+function useSwapExactInViaRouter(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => {
+			const wallet = requireWallet$1(walletClient, account);
+			return swapExactInViaRouter({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			for (const key of mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account
+			})) queryClient.invalidateQueries({ queryKey: key });
+		}
+	});
+}
+/**
+* Execute an exact-out spot swap via the Universal Router.
+*/
+function useSwapExactOutViaRouter(poolAddress) {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => {
+			const wallet = requireWallet$1(walletClient, account);
+			return swapExactOutViaRouter({
+				client: publicClient,
+				...wallet,
+				poolAddress,
+				chainId,
+				...params
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			for (const key of mutationEffects.deposit({
+				chainId,
+				poolAddress,
+				account
+			})) queryClient.invalidateQueries({ queryKey: key });
+		}
+	});
+}
+/**
+* Step 1 approval mutation: ERC20 → Permit2.
+*/
+function useApproveErc20ForPermit2() {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	return useMutation({ mutationFn: (params) => {
+		const wallet = requireWallet$1(walletClient, account);
+		return approveErc20ForPermit2({
+			client: publicClient,
+			...wallet,
+			chainId,
+			...params
+		});
+	} });
+}
+/**
+* Step 2 approval mutation: Permit2 → Universal Router.
+*/
+function useApproveRouterViaPermit2() {
+	const { publicClient, chainId, walletClient, account } = usePanopticContext();
+	return useMutation({ mutationFn: (params) => {
+		const wallet = requireWallet$1(walletClient, account);
+		return approveRouterViaPermit2({
+			client: publicClient,
+			...wallet,
+			chainId,
+			...params
+		});
+	} });
+}
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/cowSwap.ts
+function requireWallet(walletClient, account) {
+	if (!walletClient || !account) throw new PanopticError("walletClient and account are required. Provide them via PanopticProvider.");
+	return {
+		walletClient,
+		account
+	};
+}
+/** How often open-order status is re-polled (ms). */
+const ORDER_POLL_INTERVAL_MS = 5e3;
+/** How often quotes refresh (ms) — CoW quotes go stale quickly. */
+const QUOTE_REFETCH_INTERVAL_MS = 15e3;
+/**
+* Placeholder order owner for quotes when no wallet is connected — the order
+* book accepts any non-zero `from` for quoting (verification happens at order
+* submission, which always uses the real account).
+*/
+const QUOTE_STUB_FROM = "0x0000000000000000000000000000000000000001";
+/**
+* Quote a swap via the CoW order book. The connected account (or a stub when
+* disconnected) is used as the order owner (`from`); disabled while the chain
+* has no order book.
+*/
+function useQuoteCowSwap(params) {
+	const { publicClient, chainId, account, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"cowSwap",
+			"quote",
+			chainId,
+			params?.sellToken,
+			params?.buyToken,
+			params?.kind,
+			params?.amount?.toString(),
+			params?.slippageBps?.toString(),
+			account,
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => quoteCowSwap({
+			chainId,
+			from: account ?? QUOTE_STUB_FROM,
+			...params
+		}),
+		enabled: params !== void 0 && isCowSupportedChain(chainId),
+		staleTime: 0,
+		refetchInterval: QUOTE_REFETCH_INTERVAL_MS
+	});
+}
+/** Check the ERC20 → GPv2VaultRelayer allowance for the sell token. */
+function useCheckCowApproval(params) {
+	const { publicClient, chainId, clientScope } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"cowSwap",
+			"approval",
+			chainId,
+			params?.sellToken,
+			params?.owner,
+			params?.amount?.toString(),
+			getClientCacheScopeKey(publicClient, clientScope)
+		],
+		queryFn: () => checkCowApproval({
+			client: publicClient,
+			...params
+		}),
+		enabled: params !== void 0,
+		staleTime: 0
+	});
+}
+/** Approval mutation: ERC20 → GPv2VaultRelayer (single step, no Permit2). */
+function useApproveErc20ForCow() {
+	const { publicClient, walletClient, account } = usePanopticContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => {
+			const wallet = requireWallet(walletClient, account);
+			return approveErc20ForCow({
+				client: publicClient,
+				...wallet,
+				...params
+			});
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [
+				...queryKeys.all,
+				"cowSwap",
+				"approval"
+			] });
+		}
+	});
+}
+/**
+* Sign an order (EIP-712) and post it to the order book. Resolves with the
+* order UID — not a tx hash; settlement is asynchronous.
+*/
+function useSubmitCowOrder() {
+	const { chainId, walletClient, account } = usePanopticContext();
+	return useMutation({ mutationFn: (params) => {
+		const wallet = requireWallet(walletClient, account);
+		return signAndSubmitCowOrder({
+			...wallet,
+			chainId,
+			...params
+		});
+	} });
+}
+/**
+* Poll an order's lifecycle state every few seconds while it is open; polling
+* stops automatically once the order reaches a terminal state.
+*/
+function useCowOrderStatus(orderUid) {
+	const { chainId } = usePanopticContext();
+	return useQuery({
+		queryKey: [
+			...queryKeys.all,
+			"cowSwap",
+			"orderStatus",
+			chainId,
+			orderUid
+		],
+		queryFn: () => getCowOrderStatus({
+			chainId,
+			orderUid
+		}),
+		enabled: orderUid !== void 0,
+		refetchInterval: (query) => {
+			const status = query.state.data?.status;
+			return status === void 0 || status === "open" || status === "presignaturePending" ? ORDER_POLL_INTERVAL_MS : false;
+		}
+	});
+}
+/** Off-chain (signed, free) order cancellation mutation. */
+function useCancelCowOrder() {
+	const { chainId, walletClient, account } = usePanopticContext();
+	return useMutation({ mutationFn: (params) => {
+		const wallet = requireWallet(walletClient, account);
+		return cancelCowOrder({
+			...wallet,
+			chainId,
+			...params
+		});
+	} });
+}
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/sync.ts
+/**
+* Hook for syncing positions with progress tracking.
+*/
+function useSyncPositions(poolAddress) {
+	const { publicClient, chainId } = usePanopticContext();
+	const storage = useRequireStorage();
+	const account = usePanopticContext().account;
+	const queryClient = useQueryClient();
+	const [progress, setProgress] = useState(null);
+	const mutation = useMutation({
+		mutationFn: async (params) => {
+			if (!account) throw new Error("account is required for sync");
+			const result = await syncPositions({
+				client: publicClient,
+				chainId,
+				poolAddress,
+				account,
+				storage,
+				fromBlock: params?.fromBlock,
+				toBlock: params?.toBlock,
+				onUpdate: setProgress
+			});
+			return result;
+		},
+		onSuccess: () => {
+			if (!account) return;
+			queryClient.invalidateQueries({ queryKey: queryKeys.trackedPositionIds(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.syncStatus(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.positions(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.closedPositions(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.tradeHistory(chainId, poolAddress, account) });
+		}
+	});
+	return {
+		...mutation,
+		progress
+	};
+}
+/**
+* Hook for adding a pending position (optimistic update).
+*/
+function useAddPendingPosition(poolAddress) {
+	const { chainId } = usePanopticContext();
+	const storage = useRequireStorage();
+	const account = usePanopticContext().account;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (position) => {
+			if (!account) throw new Error("account is required");
+			return addPendingPosition({
+				chainId,
+				poolAddress,
+				account,
+				storage,
+				position
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			queryClient.invalidateQueries({ queryKey: queryKeys.trackedPositionIds(chainId, poolAddress, account) });
+		}
+	});
+}
+/**
+* Hook for confirming a pending position.
+*/
+function useConfirmPendingPosition(poolAddress) {
+	const { chainId } = usePanopticContext();
+	const storage = useRequireStorage();
+	const account = usePanopticContext().account;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (tokenId) => {
+			if (!account) throw new Error("account is required");
+			return confirmPendingPosition({
+				chainId,
+				poolAddress,
+				account,
+				storage,
+				tokenId
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			queryClient.invalidateQueries({ queryKey: queryKeys.trackedPositionIds(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.positions(chainId, poolAddress, account) });
+		}
+	});
+}
+/**
+* Hook for marking a pending position as failed.
+*/
+function useFailPendingPosition(poolAddress) {
+	const { chainId } = usePanopticContext();
+	const storage = useRequireStorage();
+	const account = usePanopticContext().account;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (txHash) => {
+			if (!account) throw new Error("account is required");
+			return failPendingPosition({
+				chainId,
+				poolAddress,
+				account,
+				storage,
+				txHash
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			queryClient.invalidateQueries({ queryKey: queryKeys.trackedPositionIds(chainId, poolAddress, account) });
+		}
+	});
+}
+/**
+* Hook for clearing all tracked positions.
+*/
+function useClearTrackedPositions(poolAddress) {
+	const { chainId } = usePanopticContext();
+	const storage = useRequireStorage();
+	const account = usePanopticContext().account;
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: () => {
+			if (!account) throw new Error("account is required");
+			return clearTrackedPositions({
+				chainId,
+				poolAddress,
+				account,
+				storage
+			});
+		},
+		onSuccess: () => {
+			if (!account) return;
+			queryClient.invalidateQueries({ queryKey: queryKeys.trackedPositionIds(chainId, poolAddress, account) });
+			queryClient.invalidateQueries({ queryKey: queryKeys.positions(chainId, poolAddress, account) });
+		}
+	});
+}
+
+//#endregion
+//#region src/panoptic/v2/react/hooks/events.ts
+/**
+* Watch events via WebSocket. Returns cleanup automatically on unmount.
+*/
+function useWatchEvents(poolAddress, eventTypes, onEvent, options) {
+	const { publicClient } = usePanopticContext();
+	const onEventRef = useRef(onEvent);
+	onEventRef.current = onEvent;
+	const onErrorRef = useRef(options?.onError);
+	onErrorRef.current = options?.onError;
+	const eventTypesKey = eventTypes?.join(",");
+	useEffect(() => {
+		if (options?.enabled === false) return;
+		const unwatch = watchEvents({
+			client: publicClient,
+			poolAddress,
+			eventTypes,
+			collateralTracker0: options?.collateralTracker0,
+			collateralTracker1: options?.collateralTracker1,
+			riskEngineAddress: options?.riskEngineAddress,
+			sfpmAddress: options?.sfpmAddress,
+			poolManagerAddress: options?.poolManagerAddress,
+			onLogs: (events) => onEventRef.current(events),
+			onError: (error) => onErrorRef.current?.(error)
+		});
+		return unwatch;
+	}, [
+		publicClient,
+		poolAddress,
+		options?.enabled,
+		options?.collateralTracker0,
+		options?.collateralTracker1,
+		options?.riskEngineAddress,
+		options?.sfpmAddress,
+		options?.poolManagerAddress,
+		eventTypesKey
+	]);
+}
+/**
+* Create a resilient event subscription with auto-reconnect.
+*/
+function useEventSubscription(poolAddress, eventTypes, onEvent, options) {
+	const { publicClient } = usePanopticContext();
+	const onEventRef = useRef(onEvent);
+	onEventRef.current = onEvent;
+	const onErrorRef = useRef(options?.onError);
+	onErrorRef.current = options?.onError;
+	const onReconnectRef = useRef(options?.onReconnect);
+	onReconnectRef.current = options?.onReconnect;
+	const onConnectedRef = useRef(options?.onConnected);
+	onConnectedRef.current = options?.onConnected;
+	const eventTypesKey = eventTypes?.join(",");
+	useEffect(() => {
+		if (options?.enabled === false) return;
+		const handle = createEventSubscription({
+			client: publicClient,
+			poolAddress,
+			eventTypes,
+			collateralTracker0: options?.collateralTracker0,
+			collateralTracker1: options?.collateralTracker1,
+			riskEngineAddress: options?.riskEngineAddress,
+			sfpmAddress: options?.sfpmAddress,
+			poolManagerAddress: options?.poolManagerAddress,
+			onLogs: (events) => onEventRef.current(events),
+			onError: (error) => onErrorRef.current?.(error),
+			onReconnect: (attempt, delay) => onReconnectRef.current?.(attempt, delay),
+			onConnected: () => onConnectedRef.current?.()
+		});
+		handle.start();
+		return () => handle.stop();
+	}, [
+		publicClient,
+		poolAddress,
+		options?.enabled,
+		options?.collateralTracker0,
+		options?.collateralTracker1,
+		options?.riskEngineAddress,
+		options?.sfpmAddress,
+		options?.poolManagerAddress,
+		eventTypesKey
+	]);
+}
+/**
+* Create an HTTP polling event fetcher.
+*/
+function useEventPoller(poolAddress, eventTypes, onEvent, options) {
+	const { publicClient } = usePanopticContext();
+	const onEventRef = useRef(onEvent);
+	onEventRef.current = onEvent;
+	const onErrorRef = useRef(options?.onError);
+	onErrorRef.current = options?.onError;
+	const eventTypesKey = eventTypes?.join(",");
+	useEffect(() => {
+		if (options?.enabled === false) return;
+		const poller = createEventPoller({
+			client: publicClient,
+			poolAddress,
+			eventTypes,
+			collateralTracker0: options?.collateralTracker0,
+			collateralTracker1: options?.collateralTracker1,
+			riskEngineAddress: options?.riskEngineAddress,
+			sfpmAddress: options?.sfpmAddress,
+			poolManagerAddress: options?.poolManagerAddress,
+			intervalMs: options?.intervalMs,
+			onLogs: (events) => onEventRef.current(events),
+			onError: (error) => onErrorRef.current?.(error)
+		});
+		poller.start();
+		return () => poller.stop();
+	}, [
+		publicClient,
+		poolAddress,
+		options?.enabled,
+		options?.intervalMs,
+		options?.collateralTracker0,
+		options?.collateralTracker1,
+		options?.riskEngineAddress,
+		options?.sfpmAddress,
+		options?.poolManagerAddress,
+		eventTypesKey
+	]);
+}
+/**
+* Confirms a transaction by watching for its corresponding on-chain event.
+*
+* An event log only exists in a confirmed (non-reverted) transaction, so
+* matching on `transactionHash` is sufficient proof of 1-block inclusion.
+* This bypasses the N-block confirmation wait of `useWaitForTransactionReceipt`,
+* making it faster on chains with high confirmation counts (e.g. Base = 150 blocks).
+*
+* Use alongside `useWaitForTransactionReceipt` (confirmations: 1) for revert
+* detection — reverted transactions emit no events.
+*
+* @example
+* ```tsx
+* const confirmation = useTxEventConfirmation({
+*   txHash: write.data,
+*   poolAddress,
+*   eventType: 'OptionMinted',
+*   enabled: write.data !== undefined,
+* })
+*
+* useEffect(() => {
+*   if (confirmation.isSuccess) onSuccess?.()
+* }, [confirmation.isSuccess])
+* ```
+*/
+function useTxEventConfirmation({ txHash, poolAddress = zeroAddress, collateralTrackerAddress, eventType, enabled = true, intervalMs = 3000n }) {
+	const { publicClient } = usePanopticContext();
+	const [data, setData] = useState();
+	const [isLoading, setIsLoading] = useState(false);
+	const txHashRef = useRef(txHash);
+	txHashRef.current = txHash;
+	const confirmedRef = useRef(false);
+	const pollerRef = useRef(null);
+	useEffect(() => {
+		confirmedRef.current = false;
+		setData(void 0);
+		if (!txHash || !enabled) {
+			pollerRef.current?.stop();
+			pollerRef.current = null;
+			setIsLoading(false);
+			return;
+		}
+		setIsLoading(true);
+		let cancelled = false;
+		publicClient.getBlockNumber().then((currentBlock) => {
+			if (cancelled) return;
+			const fromBlock = currentBlock > 0n ? currentBlock - 1n : 0n;
+			const poller = createEventPoller({
+				client: publicClient,
+				poolAddress,
+				collateralTracker0: collateralTrackerAddress,
+				eventTypes: [eventType],
+				intervalMs,
+				fromBlock,
+				onLogs: (events) => {
+					const hash = txHashRef.current;
+					if (!hash || confirmedRef.current) return;
+					const match = events.find((e) => e.transactionHash === hash);
+					if (match) {
+						confirmedRef.current = true;
+						pollerRef.current?.stop();
+						pollerRef.current = null;
+						setIsLoading(false);
+						setData(match);
+					}
+				}
+			});
+			pollerRef.current = poller;
+			poller.start();
+		}).catch(() => {
+			if (cancelled || confirmedRef.current) return;
+			pollerRef.current?.stop();
+			pollerRef.current = null;
+			setIsLoading(false);
+		});
+		return () => {
+			cancelled = true;
+			pollerRef.current?.stop();
+			pollerRef.current = null;
+		};
+	}, [
+		txHash,
+		enabled,
+		publicClient,
+		poolAddress,
+		collateralTrackerAddress,
+		eventType,
+		intervalMs
+	]);
+	return {
+		data,
+		isLoading: isLoading && data === void 0,
+		isSuccess: data !== void 0
+	};
+}
+
+//#endregion
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, estimateBlockNumbers, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, fetchPoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getOpenPositionIds, getOpenPositionPreview, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, smartRepay, smartRepayAndWait, speedUpTransaction, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+//# sourceMappingURL=react-public.js.map