@panoptic-eng/sdk 1.0.63 → 1.0.65

package/dist/uniswap/index.js

@@ -1,5 +1,7 @@
 import Decimal from "decimal.js";
-import { BaseError, ContractFunctionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, isAddressEqual, keccak256, maxUint256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
+import { BaseError, ContractFunctionRevertedError, ExecutionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, isAddressEqual, keccak256, maxUint256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod";
 
 //#region src/uniswap/estimateLpFees.ts
 const D$1 = Decimal.clone({ precision: 60 });
@@ -126,6 +128,28 @@ function estimateLpFees({ candles, ranges, feePips }) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/clients/blockMeta.ts
+/**
+* Get block metadata for a given block.
+* Used to tag all read results with same-block consistency proof.
+*
+* @param params - The parameters
+* @returns Block metadata
+*/
+async function getBlockMeta(params) {
+	const { client, blockNumber } = params;
+	const block = await client.getBlock({
+		blockNumber,
+		includeTransactions: false
+	});
+	return {
+		blockNumber: block.number,
+		blockHash: block.hash,
+		blockTimestamp: block.timestamp
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/utils/constants.ts
 /**
@@ -158,7 +182,7 @@ const NO_UPPER_LIQUIDATION_TICK = (1n << 23n) - 1n;
 
 //#endregion
 //#region src/panoptic/v2/formatters/tick.ts
-const Q192$5 = 1n << 192n;
+const Q192$6 = 1n << 192n;
 const RAW_PRICE_PRECISION = 40n;
 function pow10(exponent) {
 	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
@@ -216,7 +240,7 @@ const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
 function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
 	return {
 		numerator: sqrtPriceX96 * sqrtPriceX96,
-		denominator: Q192$5
+		denominator: Q192$6
 	};
 }
 function getRawPriceRatio(tick) {
@@ -247,137 +271,872 @@ function tickToPrice(tick) {
 }
 
 //#endregion
-//#region src/panoptic/v2/errors/base.ts
-/**
-* Base error class for the Panoptic v2 SDK.
-* @module v2/errors/base
-*/
+//#region src/panoptic/v2/abis/stateView.ts
 /**
-* Base error class for all Panoptic SDK errors.
-* All errors thrown by the SDK extend this class.
-*
-* @example
-* ```typescript
-* try {
-*   await openPosition(config, params)
-* } catch (error) {
-*   if (error instanceof PanopticError) {
-*     console.log('Panoptic error:', error.name, error.message)
-*     console.log('Original cause:', error.cause)
-*   }
-* }
-* ```
+* Minimal Uniswap V4 StateView ABI for fee growth reads.
+* Only includes functions needed by streamia history.
 */
-var PanopticError = class extends Error {
-	name = "PanopticError";
-	/** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
-	errorName;
-	/**
-	* Creates a new PanopticError.
-	*
-	* @param message - Human-readable error message
-	* @param cause - Optional underlying error that caused this error
-	*/
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-		Object.setPrototypeOf(this, new.target.prototype);
+const stateViewAbi = [
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getSlot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint24",
+				name: "protocolFee",
+				type: "uint24"
+			},
+			{
+				internalType: "uint24",
+				name: "lpFee",
+				type: "uint24"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getFeeGrowthGlobals",
+		outputs: [{
+			internalType: "uint256",
+			name: "feeGrowthGlobal0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "feeGrowthGlobal1",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}, {
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		}],
+		name: "getTickInfo",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getLiquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "liquidity",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
 	}
-};
+];
 
 //#endregion
-//#region src/panoptic/v2/errors/contract.ts
-/**
-* The account is not solvent enough to perform the desired action.
-* @see Errors.sol:9
-*/
-var AccountInsolventError = class extends PanopticError {
-	name = "AccountInsolventError";
-	constructor(solvent, numberOfTicks, cause) {
-		super(`Account insolvent: solvent=${solvent}, numberOfTicks=${numberOfTicks}`, cause);
-		this.solvent = solvent;
-		this.numberOfTicks = numberOfTicks;
-	}
-};
-/**
-* Position is still solvent and cannot be liquidated.
-* @see Errors.sol:84
-*/
-var NotMarginCalledError = class extends PanopticError {
-	name = "NotMarginCalledError";
-	constructor(cause) {
-		super("Position is still solvent and cannot be liquidated", cause);
-	}
-};
-/**
-* The user does not own enough assets to open/close a position.
-* @see Errors.sol:78
-*/
-var NotEnoughTokensError = class extends PanopticError {
-	name = "NotEnoughTokensError";
-	constructor(tokenAddress, assetsRequested, assetBalance, cause) {
-		super(`Not enough tokens: requested=${assetsRequested}, balance=${assetBalance}, token=${tokenAddress}`, cause);
-		this.tokenAddress = tokenAddress;
-		this.assetsRequested = assetsRequested;
-		this.assetBalance = assetBalance;
-	}
-};
-/**
-* There is not enough available liquidity in the chunk for a long leg.
-* @see Errors.sol:75
-*/
-var NotEnoughLiquidityInChunkError = class extends PanopticError {
-	name = "NotEnoughLiquidityInChunkError";
-	constructor(cause) {
-		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
-	}
-};
-/**
-* There is not enough available liquidity to fulfill a credit.
-* @see Errors.sol:47
-*/
-var InsufficientCreditLiquidityError = class extends PanopticError {
-	name = "InsufficientCreditLiquidityError";
-	constructor(cause) {
-		super("Insufficient credit liquidity available in the PanopticPool", cause);
-	}
-};
-/**
-* The amount deposited is larger than the maximum permitted.
-* @see Errors.sol:25
-*/
-var DepositTooLargeError = class extends PanopticError {
-	name = "DepositTooLargeError";
-	constructor(cause) {
-		super("Deposit amount exceeds maximum permitted", cause);
-	}
-};
-/**
-* Attempted to withdraw/redeem less than a single asset.
-* @see Errors.sol:16
-*/
-var BelowMinimumRedemptionError = class extends PanopticError {
-	name = "BelowMinimumRedemptionError";
-	constructor(cause) {
-		super("Redemption amount below minimum threshold", cause);
-	}
-};
-/**
-* Attempted to withdraw/redeem more than available.
-* @see Errors.sol:35
-*/
-var ExceedsMaximumRedemptionError = class extends PanopticError {
-	name = "ExceedsMaximumRedemptionError";
-	constructor(cause) {
-		super("Redemption exceeds maximum available (liquidity, shares, or open positions)", cause);
-	}
-};
+//#region src/panoptic/v2/abis/uniswapV3Pool.ts
 /**
-* Mints/burns of a position returns no collateral requirement.
-* @see Errors.sol:141
+* Minimal Uniswap V3 Pool ABI for fee growth reads.
+* Only includes functions needed by streamia history.
 */
-var ZeroCollateralRequirementError = class extends PanopticError {
+const uniswapV3PoolAbi = [
+	{
+		inputs: [],
+		name: "slot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint16",
+				name: "observationIndex",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinality",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinalityNext",
+				type: "uint16"
+			},
+			{
+				internalType: "uint8",
+				name: "feeProtocol",
+				type: "uint8"
+			},
+			{
+				internalType: "bool",
+				name: "unlocked",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal0X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal1X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		name: "ticks",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulativeOutside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityOutsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsOutside",
+				type: "uint32"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "liquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "fee",
+		outputs: [{
+			internalType: "uint24",
+			name: "",
+			type: "uint24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token0",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token1",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "tickSpacing",
+		outputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/reads/priceHistory.ts
+/**
+* Get historical price data (tick + sqrtPriceX96) for a pool across multiple blocks.
+*
+* @param params - The parameters
+* @returns Price snapshots at each block
+*
+* @example
+* ```typescript
+* const { snapshots } = await getPriceHistory({
+*   client,
+*   blockNumbers: [18000000n, 18000100n, 18000200n],
+*   poolConfig: { version: 'v3', poolAddress: '0x...' },
+* })
+*
+* for (const snap of snapshots) {
+*   console.log(`Block ${snap.blockNumber}: tick=${snap.tick}`)
+* }
+* ```
+*/
+async function getPriceHistory(params) {
+	const { client, blockNumbers, poolConfig } = params;
+	if (blockNumbers.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({ client });
+		return {
+			snapshots: [],
+			_meta: _meta$1
+		};
+	}
+	const slot0Requests = blockNumbers.map((bn) => fetchSlot0(client, bn, poolConfig));
+	const [slot0Results, _meta] = await Promise.all([Promise.all(slot0Requests), params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })]);
+	const snapshots = slot0Results.map((result, i) => ({
+		blockNumber: blockNumbers[i],
+		tick: result.tick,
+		sqrtPriceX96: result.sqrtPriceX96
+	}));
+	return {
+		snapshots,
+		_meta
+	};
+}
+async function fetchSlot0(client, blockNumber, poolConfig) {
+	if (poolConfig.version === "v3") {
+		const result = await client.readContract({
+			address: poolConfig.poolAddress,
+			abi: uniswapV3PoolAbi,
+			functionName: "slot0",
+			blockNumber
+		});
+		return {
+			sqrtPriceX96: result[0],
+			tick: result[1]
+		};
+	} else {
+		const result = await client.readContract({
+			address: poolConfig.stateViewAddress,
+			abi: stateViewAbi,
+			functionName: "getSlot0",
+			args: [poolConfig.poolId],
+			blockNumber
+		});
+		return {
+			sqrtPriceX96: result[0],
+			tick: result[1]
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/uniswapLpPosition.ts
+const nfpmAbi = [{
+	type: "function",
+	name: "positions",
+	inputs: [{
+		name: "tokenId",
+		type: "uint256"
+	}],
+	outputs: [
+		{
+			name: "nonce",
+			type: "uint96"
+		},
+		{
+			name: "operator",
+			type: "address"
+		},
+		{
+			name: "token0",
+			type: "address"
+		},
+		{
+			name: "token1",
+			type: "address"
+		},
+		{
+			name: "fee",
+			type: "uint24"
+		},
+		{
+			name: "tickLower",
+			type: "int24"
+		},
+		{
+			name: "tickUpper",
+			type: "int24"
+		},
+		{
+			name: "liquidity",
+			type: "uint128"
+		},
+		{
+			name: "feeGrowthInside0LastX128",
+			type: "uint256"
+		},
+		{
+			name: "feeGrowthInside1LastX128",
+			type: "uint256"
+		},
+		{
+			name: "tokensOwed0",
+			type: "uint128"
+		},
+		{
+			name: "tokensOwed1",
+			type: "uint128"
+		}
+	],
+	stateMutability: "view"
+}, {
+	type: "function",
+	name: "collect",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				name: "recipient",
+				type: "address"
+			},
+			{
+				name: "amount0Max",
+				type: "uint128"
+			},
+			{
+				name: "amount1Max",
+				type: "uint128"
+			}
+		]
+	}],
+	outputs: [{
+		name: "amount0",
+		type: "uint256"
+	}, {
+		name: "amount1",
+		type: "uint256"
+	}],
+	stateMutability: "payable"
+}];
+const MAX_UINT128$3 = 2n ** 128n - 1n;
+const MAX_UINT256$1 = 2n ** 256n - 1n;
+const Q128 = 2n ** 128n;
+/**
+* Whether an error thrown by a viem contract call is an on-chain revert (as
+* opposed to a transport/RPC failure such as a timeout or rate limit).
+*/
+function isContractRevert(error) {
+	return error instanceof BaseError && error.walk((err) => err instanceof ContractFunctionRevertedError || err instanceof ExecutionRevertedError) != null;
+}
+/**
+* Fetch a Uniswap V3 LP position's state and uncollected fees.
+*
+* Fees come from simulating `collect` with max amounts as the owner — one
+* eth_call returning the exact claimable amounts (tokensOwed + fee growth
+* since the last poke). The simulation is best-effort: if it reverts (e.g.
+* an empty position), fees fall back to 0.
+*/
+async function getUniswapV3LpPositionState(params) {
+	const { client, nfpmAddress, tokenId, owner, blockNumber } = params;
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	const position = await client.readContract({
+		address: nfpmAddress,
+		abi: nfpmAbi,
+		functionName: "positions",
+		args: [tokenId],
+		blockNumber: _meta.blockNumber
+	});
+	const [, , token0, token1, fee, tickLower, tickUpper, liquidity] = position;
+	let fees0 = 0n;
+	let fees1 = 0n;
+	try {
+		const { result } = await client.simulateContract({
+			address: nfpmAddress,
+			abi: nfpmAbi,
+			functionName: "collect",
+			args: [{
+				tokenId,
+				recipient: owner,
+				amount0Max: MAX_UINT128$3,
+				amount1Max: MAX_UINT128$3
+			}],
+			account: owner,
+			blockNumber: _meta.blockNumber
+		});
+		[fees0, fees1] = result;
+	} catch (error) {
+		if (!isContractRevert(error)) throw error;
+	}
+	return {
+		token0,
+		token1,
+		fee: Number(fee),
+		tickLower: Number(tickLower),
+		tickUpper: Number(tickUpper),
+		liquidity,
+		fees0,
+		fees1,
+		_meta
+	};
+}
+
+//#endregion
+//#region src/uniswap/lpGreeks.ts
+const Q96$4 = 1n << 96n;
+const Q192$5 = 1n << 192n;
+/**
+* Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
+* at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
+* (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
+* clamped into the range, so out-of-range positions collapse to a single token.
+*/
+function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
+	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
+	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
+	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$4 / (sqrtC * sqrtB) : 0n;
+	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$4 : 0n;
+	return {
+		amount0,
+		amount1
+	};
+}
+/**
+* Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
+* frame. See the module docs for the unit conventions.
+*
+* Closed forms (in-range, numeraire = token1 / asset = token0):
+*   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
+*   delta = amount0                            (= dV/dP)
+*   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
+* The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
+* Gamma is zero when the price is outside the range (no curvature there).
+*/
+function getLpGreeks(input) {
+	const { liquidity, tickLower, tickUpper, currentTick, assetIndex } = input;
+	const sqrtP = input.sqrtPriceX96 ?? tickToSqrtPriceX96(currentTick);
+	if (sqrtP <= 0n) throw new RangeError("Invalid sqrt price");
+	const sqrtA = tickToSqrtPriceX96(tickLower);
+	const sqrtB = tickToSqrtPriceX96(tickUpper);
+	const { amount0, amount1 } = getAmountsForLiquidity(sqrtP, sqrtA, sqrtB, liquidity);
+	const sqrtP2 = sqrtP * sqrtP;
+	const inRange = sqrtP > sqrtA && sqrtP < sqrtB;
+	if (assetIndex === 0) {
+		const value$1 = amount1 + amount0 * sqrtP2 / Q192$5;
+		const delta$1 = amount0;
+		const gamma$1 = inRange ? -(liquidity * sqrtP) / (2n * Q96$4) : 0n;
+		return {
+			value: value$1,
+			delta: delta$1,
+			gamma: gamma$1
+		};
+	}
+	const value = amount0 + amount1 * Q192$5 / sqrtP2;
+	const delta = amount1;
+	const gamma = inRange ? -(liquidity * Q96$4) / (2n * sqrtP) : 0n;
+	return {
+		value,
+		delta,
+		gamma
+	};
+}
+
+//#endregion
+//#region src/uniswap/lpAccounting.ts
+const Precision$2 = Decimal.clone({ precision: 80 });
+const Q192$4 = (1n << 192n).toString();
+function reconcileV3LpFees(events, claimable, endBlock) {
+	let collected0 = 0n;
+	let collected1 = 0n;
+	let removed0 = 0n;
+	let removed1 = 0n;
+	for (const event of events) {
+		if (event.amountSource !== "ExactEvent" || event.blockNumber > endBlock) throw new Error("Complete exact v3 history is required");
+		if (event.eventType === "Collect") {
+			collected0 += event.amount0;
+			collected1 += event.amount1;
+		} else if (event.eventType === "Burn") {
+			removed0 += event.amount0;
+			removed1 += event.amount1;
+		}
+	}
+	const fees0 = collected0 + claimable.amount0 - removed0;
+	const fees1 = collected1 + claimable.amount1 - removed1;
+	if (fees0 < 0n || fees1 < 0n) throw new Error("LP fee accounting does not reconcile");
+	return {
+		fees0,
+		fees1
+	};
+}
+/** V3 NFT cash-flow returns, including withdrawn principal still awaiting collection. */
+function calculateV3LpAccounting({ events, inventory, claimable, prices, endBlock, token0Decimals, token1Decimals }) {
+	for (const decimals of [token0Decimals, token1Decimals]) if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255) throw new RangeError("Invalid token decimals");
+	const priceByBlock = new Map(prices.map((point) => {
+		if (point.sqrtPriceX96 <= 0n) throw new RangeError("Invalid historical price");
+		return [point.blockNumber, new Precision$2(point.sqrtPriceX96.toString()).pow(2).div(Q192$4)];
+	}));
+	const priceAt = (block) => {
+		const price = priceByBlock.get(block);
+		if (!price) throw new Error("Historical price unavailable");
+		return price;
+	};
+	const { fees0, fees1 } = reconcileV3LpFees(events, claimable, endBlock);
+	const frame = (quoteIsToken0, decimals) => {
+		const scale = new Precision$2(10).pow(decimals);
+		const value = (amount0, amount1, block) => {
+			const price = priceAt(block);
+			return (quoteIsToken0 ? new Precision$2(amount0.toString()).plus(new Precision$2(amount1.toString()).div(price)) : new Precision$2(amount1.toString()).plus(new Precision$2(amount0.toString()).mul(price))).div(scale);
+		};
+		let deposited = new Precision$2(0);
+		let collected = new Precision$2(0);
+		for (const event of events) {
+			if (event.eventType === "Mint") deposited = deposited.plus(value(event.amount0, event.amount1, event.blockNumber));
+			if (event.eventType === "Collect") collected = collected.plus(value(event.amount0, event.amount1, event.blockNumber));
+		}
+		const endingValue = value(inventory.amount0 + claimable.amount0, inventory.amount1 + claimable.amount1, endBlock);
+		const pnl = endingValue.plus(collected).minus(deposited);
+		return {
+			pnl: pnl.toString(),
+			deposited: deposited.toString(),
+			pnlPercent: deposited.gt(0) ? pnl.div(deposited).mul(100).toString() : null
+		};
+	};
+	return {
+		fees0,
+		fees1,
+		claimable,
+		quote0: frame(true, token0Decimals),
+		quote1: frame(false, token1Decimals)
+	};
+}
+/** Reconcile v3 activity and historical prices at the subgraph's indexed block. */
+async function getV3LpHistoryAccounting({ client, history, nfpmAddress, poolAddress, tickLower, tickUpper, token0Decimals, token1Decimals }) {
+	if (history.version !== 3) throw new Error("V4 fee collections are unavailable");
+	const tokenId = BigInt(history.positionId.slice(3));
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber: history.blockNumber
+	});
+	if (_meta.blockHash.toLowerCase() !== history.blockHash.toLowerCase()) throw new Error("LP history checkpoint changed");
+	let liquidity = 0n;
+	for (const event of history.events) if (event.eventType !== "Collect") liquidity += event.eventType === "Mint" ? event.liquidity : -event.liquidity;
+	let claimable = {
+		amount0: 0n,
+		amount1: 0n
+	};
+	let owner;
+	try {
+		owner = await client.readContract({
+			address: nfpmAddress,
+			abi: parseAbi(["function ownerOf(uint256 tokenId) view returns (address)"]),
+			functionName: "ownerOf",
+			args: [tokenId],
+			blockNumber: history.blockNumber
+		});
+	} catch (error) {
+		const reverted = error instanceof BaseError && error.walk((cause) => cause instanceof ContractFunctionRevertedError || cause instanceof ExecutionRevertedError);
+		if (liquidity !== 0n || !(reverted instanceof ContractFunctionRevertedError || reverted instanceof ExecutionRevertedError)) throw error;
+	}
+	if (owner) {
+		const state = await getUniswapV3LpPositionState({
+			client,
+			nfpmAddress,
+			tokenId,
+			owner,
+			blockNumber: history.blockNumber
+		});
+		if (state.liquidity !== liquidity) throw new Error("LP liquidity history does not reconcile");
+		claimable = {
+			amount0: state.fees0,
+			amount1: state.fees1
+		};
+	}
+	const blocks = [...new Set([history.blockNumber, ...history.events.filter((event) => event.eventType !== "Burn").map((event) => event.blockNumber)])];
+	const feeTotals = reconcileV3LpFees(history.events, claimable, history.blockNumber);
+	const prices = [];
+	for (let index = 0; index < blocks.length; index += 16) {
+		const batch = blocks.slice(index, index + 16);
+		const result = await getPriceHistory({
+			client,
+			blockNumbers: batch,
+			poolConfig: {
+				version: "v3",
+				poolAddress
+			},
+			_meta
+		}).catch(() => null);
+		if (!result) return {
+			...feeTotals,
+			claimable,
+			quote0: null,
+			quote1: null,
+			blockNumber: history.blockNumber,
+			timestamp: _meta.blockTimestamp
+		};
+		result.snapshots.forEach((point, offset) => prices.push({
+			blockNumber: batch[offset],
+			sqrtPriceX96: point.sqrtPriceX96
+		}));
+	}
+	const endingPrice = prices.find((price) => price.blockNumber === history.blockNumber);
+	if (!endingPrice) throw new Error("Ending price unavailable");
+	const inventory = getAmountsForLiquidity(endingPrice.sqrtPriceX96, tickToSqrtPriceX96(tickLower), tickToSqrtPriceX96(tickUpper), liquidity);
+	return {
+		...calculateV3LpAccounting({
+			events: history.events,
+			inventory,
+			claimable,
+			prices,
+			endBlock: history.blockNumber,
+			token0Decimals,
+			token1Decimals
+		}),
+		blockNumber: history.blockNumber,
+		timestamp: _meta.blockTimestamp
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/errors/base.ts
+/**
+* Base error class for the Panoptic v2 SDK.
+* @module v2/errors/base
+*/
+/**
+* Base error class for all Panoptic SDK errors.
+* All errors thrown by the SDK extend this class.
+*
+* @example
+* ```typescript
+* try {
+*   await openPosition(config, params)
+* } catch (error) {
+*   if (error instanceof PanopticError) {
+*     console.log('Panoptic error:', error.name, error.message)
+*     console.log('Original cause:', error.cause)
+*   }
+* }
+* ```
+*/
+var PanopticError = class extends Error {
+	name = "PanopticError";
+	/** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
+	errorName;
+	/**
+	* Creates a new PanopticError.
+	*
+	* @param message - Human-readable error message
+	* @param cause - Optional underlying error that caused this error
+	*/
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+
+//#endregion
+//#region src/panoptic/v2/errors/contract.ts
+/**
+* The account is not solvent enough to perform the desired action.
+* @see Errors.sol:9
+*/
+var AccountInsolventError = class extends PanopticError {
+	name = "AccountInsolventError";
+	constructor(solvent, numberOfTicks, cause) {
+		super(`Account insolvent: solvent=${solvent}, numberOfTicks=${numberOfTicks}`, cause);
+		this.solvent = solvent;
+		this.numberOfTicks = numberOfTicks;
+	}
+};
+/**
+* Position is still solvent and cannot be liquidated.
+* @see Errors.sol:84
+*/
+var NotMarginCalledError = class extends PanopticError {
+	name = "NotMarginCalledError";
+	constructor(cause) {
+		super("Position is still solvent and cannot be liquidated", cause);
+	}
+};
+/**
+* The user does not own enough assets to open/close a position.
+* @see Errors.sol:78
+*/
+var NotEnoughTokensError = class extends PanopticError {
+	name = "NotEnoughTokensError";
+	constructor(tokenAddress, assetsRequested, assetBalance, cause) {
+		super(`Not enough tokens: requested=${assetsRequested}, balance=${assetBalance}, token=${tokenAddress}`, cause);
+		this.tokenAddress = tokenAddress;
+		this.assetsRequested = assetsRequested;
+		this.assetBalance = assetBalance;
+	}
+};
+/**
+* There is not enough available liquidity in the chunk for a long leg.
+* @see Errors.sol:75
+*/
+var NotEnoughLiquidityInChunkError = class extends PanopticError {
+	name = "NotEnoughLiquidityInChunkError";
+	constructor(cause) {
+		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
+	}
+};
+/**
+* There is not enough available liquidity to fulfill a credit.
+* @see Errors.sol:47
+*/
+var InsufficientCreditLiquidityError = class extends PanopticError {
+	name = "InsufficientCreditLiquidityError";
+	constructor(cause) {
+		super("Insufficient credit liquidity available in the PanopticPool", cause);
+	}
+};
+/**
+* The amount deposited is larger than the maximum permitted.
+* @see Errors.sol:25
+*/
+var DepositTooLargeError = class extends PanopticError {
+	name = "DepositTooLargeError";
+	constructor(cause) {
+		super("Deposit amount exceeds maximum permitted", cause);
+	}
+};
+/**
+* Attempted to withdraw/redeem less than a single asset.
+* @see Errors.sol:16
+*/
+var BelowMinimumRedemptionError = class extends PanopticError {
+	name = "BelowMinimumRedemptionError";
+	constructor(cause) {
+		super("Redemption amount below minimum threshold", cause);
+	}
+};
+/**
+* Attempted to withdraw/redeem more than available.
+* @see Errors.sol:35
+*/
+var ExceedsMaximumRedemptionError = class extends PanopticError {
+	name = "ExceedsMaximumRedemptionError";
+	constructor(cause) {
+		super("Redemption exceeds maximum available (liquidity, shares, or open positions)", cause);
+	}
+};
+/**
+* Mints/burns of a position returns no collateral requirement.
+* @see Errors.sol:141
+*/
+var ZeroCollateralRequirementError = class extends PanopticError {
 	name = "ZeroCollateralRequirementError";
 	constructor(cause) {
 		super("Position mint/burn returned zero collateral requirement", cause);
@@ -586,7 +1345,7 @@ var NoLegsExercisableError = class extends PanopticError {
 var NotALongLegError = class extends PanopticError {
 	name = "NotALongLegError";
 	constructor(cause) {
-		super("Cannot settle premium for non-long leg", cause);
+		super("Cannot settle streamia for non-long leg", cause);
 	}
 };
 /**
@@ -4514,7 +5273,7 @@ function decodeAllLegs(tokenId) {
 const POOL_ID_MASK$2 = (1n << 64n) - 1n;
 const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
 const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
-const Q192$4 = 1n << 192n;
+const Q192$3 = 1n << 192n;
 
 //#endregion
 //#region src/panoptic/v2/formatters/rates.ts
@@ -4526,7 +5285,7 @@ const SECONDS_PER_YEAR = SECONDS_PER_DAY * DAYS_PER_YEAR;
 //#region src/panoptic/v2/tokenId/generateOverlapping.ts
 const MAX_UINT64 = (1n << 64n) - 1n;
 const MAX_UINT128$2 = (1n << 128n) - 1n;
-const Q192$3 = 1n << 192n;
+const Q192$2 = 1n << 192n;
 
 //#endregion
 //#region src/panoptic/v2/tokenId/split.ts
@@ -4536,7 +5295,7 @@ const MAX_UINT256 = (1n << 256n) - 1n;
 
 //#endregion
 //#region src/uniswap/lpDeposit.ts
-const Q96$4 = 1n << 96n;
+const Q96$3 = 1n << 96n;
 const ceilDiv = (n, d) => (n + d - 1n) / d;
 /** Uniswap mint principal in raw token units, rounded up per leg, plus 5% headroom. */
 function getLpDepositAmounts(ranges, sqrtPriceX96) {
@@ -4552,8 +5311,8 @@ function getLpDepositBreakdown(ranges, sqrtPriceX96) {
 		const lower = tickToSqrtPriceX96(BigInt(tickLower));
 		const upper = tickToSqrtPriceX96(BigInt(tickUpper));
 		const price = sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96;
-		amount0 += ceilDiv(liquidity * Q96$4 * (upper - price), upper * price);
-		amount1 += ceilDiv(liquidity * (price - lower), Q96$4);
+		amount0 += ceilDiv(liquidity * Q96$3 * (upper - price), upper * price);
+		amount1 += ceilDiv(liquidity * (price - lower), Q96$3);
 	}
 	const buffer = {
 		amount0: ceilDiv(amount0 * 5n, 100n),
@@ -4581,7 +5340,7 @@ function getUnhedgedLpRanges({ tokenId, positionSize, tickSpacing }) {
 		const lower = tickToSqrtPriceX96(tickLower);
 		const upper = tickToSqrtPriceX96(tickUpper);
 		const amount = positionSize * leg.optionRatio;
-		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$4) / (upper - lower) : amount * Q96$4 / (upper - lower);
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$3) / (upper - lower) : amount * Q96$3 / (upper - lower);
 		return liquidity <= 0n ? [] : [{
 			tickLower: Number(tickLower),
 			tickUpper: Number(tickUpper),
@@ -4602,7 +5361,7 @@ function getLpPositionFunding(params) {
 	});
 	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
 	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
-	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv(amount1 * Q96$4 * Q96$4, priceSquared) : amount1 + ceilDiv(amount0 * priceSquared, Q96$4 * Q96$4);
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv(amount1 * Q96$3 * Q96$3, priceSquared) : amount1 + ceilDiv(amount0 * priceSquared, Q96$3 * Q96$3);
 	const principalInQuote = value(breakdown.principal);
 	const totalInQuote = value(breakdown.total);
 	return {
@@ -4632,8 +5391,8 @@ function getLpFundingDeposit({ funding, availableInQuote, minimumInQuote = 0n, q
 		requiredInQuote,
 		shortfallInQuote,
 		defaultQuotePercent,
-		amount0: quoteTokenIndex === 0 ? quoteAmount : ceilDiv(assetValue * Q96$4 * Q96$4, priceSquared),
-		amount1: quoteTokenIndex === 1 ? quoteAmount : ceilDiv(assetValue * priceSquared, Q96$4 * Q96$4)
+		amount0: quoteTokenIndex === 0 ? quoteAmount : ceilDiv(assetValue * Q96$3 * Q96$3, priceSquared),
+		amount1: quoteTokenIndex === 1 ? quoteAmount : ceilDiv(assetValue * priceSquared, Q96$3 * Q96$3)
 	};
 }
 /** Largest raw size funded by available collateral, including native-token rounding. */
@@ -4655,66 +5414,6 @@ function getMaxLpPositionSize(params) {
 	return low;
 }
 
-//#endregion
-//#region src/uniswap/lpGreeks.ts
-const Q96$3 = 1n << 96n;
-const Q192$2 = 1n << 192n;
-/**
-* Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
-* at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
-* (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
-* clamped into the range, so out-of-range positions collapse to a single token.
-*/
-function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
-	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
-	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
-	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$3 / (sqrtC * sqrtB) : 0n;
-	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$3 : 0n;
-	return {
-		amount0,
-		amount1
-	};
-}
-/**
-* Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
-* frame. See the module docs for the unit conventions.
-*
-* Closed forms (in-range, numeraire = token1 / asset = token0):
-*   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
-*   delta = amount0                            (= dV/dP)
-*   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
-* The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
-* Gamma is zero when the price is outside the range (no curvature there).
-*/
-function getLpGreeks(input) {
-	const { liquidity, tickLower, tickUpper, currentTick, assetIndex } = input;
-	const sqrtP = input.sqrtPriceX96 ?? tickToSqrtPriceX96(currentTick);
-	if (sqrtP <= 0n) throw new RangeError("Invalid sqrt price");
-	const sqrtA = tickToSqrtPriceX96(tickLower);
-	const sqrtB = tickToSqrtPriceX96(tickUpper);
-	const { amount0, amount1 } = getAmountsForLiquidity(sqrtP, sqrtA, sqrtB, liquidity);
-	const sqrtP2 = sqrtP * sqrtP;
-	const inRange = sqrtP > sqrtA && sqrtP < sqrtB;
-	if (assetIndex === 0) {
-		const value$1 = amount1 + amount0 * sqrtP2 / Q192$2;
-		const delta$1 = amount0;
-		const gamma$1 = inRange ? -(liquidity * sqrtP) / (2n * Q96$3) : 0n;
-		return {
-			value: value$1,
-			delta: delta$1,
-			gamma: gamma$1
-		};
-	}
-	const value = amount0 + amount1 * Q192$2 / sqrtP2;
-	const delta = amount1;
-	const gamma = inRange ? -(liquidity * Q96$3) / (2n * sqrtP) : 0n;
-	return {
-		value,
-		delta,
-		gamma
-	};
-}
-
 //#endregion
 //#region src/uniswap/lpFeeReturn.ts
 const D = Decimal.clone({ precision: 60 });
@@ -4756,6 +5455,146 @@ function getLpFeeReturnSeries({ points, ranges, startTick }) {
 	});
 }
 
+//#endregion
+//#region src/uniswap/lpHistory.ts
+const unsigned = z.string().regex(/^\d+$/).transform(BigInt);
+const eventFields = {
+	id: z.string().min(1),
+	hash: z.string().regex(/^0x[0-9a-fA-F]{64}$/),
+	blockNumber: unsigned,
+	logIndex: unsigned,
+	timestamp: unsigned,
+	amount0: unsigned,
+	amount1: unsigned
+};
+const changeSchema = z.object({
+	...eventFields,
+	eventType: z.enum(["Mint", "Burn"]),
+	liquidity: unsigned,
+	amountSource: z.string().nullable()
+});
+const collectSchema = z.object({
+	...eventFields,
+	recipient: z.string().regex(/^0x[0-9a-fA-F]{40}$/)
+});
+const pageSchema = z.object({
+	_meta: z.object({
+		block: z.object({
+			number: z.number().int().nonnegative(),
+			hash: z.string().regex(/^0x[0-9a-fA-F]{64}$/)
+		}),
+		hasIndexingErrors: z.boolean()
+	}),
+	uniswapLpPosition: z.object({
+		version: z.union([z.literal(3), z.literal(4)]),
+		liquidity: unsigned,
+		liquidityChanges: z.array(changeSchema),
+		collects: z.array(collectSchema)
+	}).nullable()
+});
+const HISTORY_QUERY = `
+  query LpPositionActivity($positionId: ID!, $block: Block_height, $changeCursor: ID!, $collectCursor: ID!, $pageSize: Int!) {
+    _meta(block: $block) { block { number hash } hasIndexingErrors }
+    uniswapLpPosition(id: $positionId, block: $block) {
+      version
+      liquidity
+      liquidityChanges(first: $pageSize, where: { id_gt: $changeCursor }, orderBy: id, orderDirection: asc) {
+        id hash eventType liquidity amount0 amount1 amountSource blockNumber logIndex timestamp
+      }
+      collects(first: $pageSize, where: { id_gt: $collectCursor }, orderBy: id, orderDirection: asc) {
+        id hash amount0 amount1 blockNumber logIndex timestamp recipient
+      }
+    }
+  }
+`;
+/** Complete NFT activity at one indexed block, sorted by block and log index. */
+async function getLpPositionHistory({ url, positionId, signal }) {
+	if (!/^v[34]-\d+$/.test(positionId)) throw new RangeError("Invalid LP position id");
+	const client = new GraphQLClient(url, { signal });
+	const events = [];
+	let block = null;
+	let changeCursor = "";
+	let collectCursor = "";
+	while (true) {
+		const page = pageSchema.parse(await client.request(HISTORY_QUERY, {
+			positionId,
+			block,
+			changeCursor,
+			collectCursor,
+			pageSize: 1e3
+		}));
+		if (page._meta.hasIndexingErrors) throw new Error("LP history indexing is incomplete");
+		const position = page.uniswapLpPosition;
+		if (!position) throw new Error("LP position history is unavailable");
+		if (position.version !== Number(positionId[1])) throw new Error("LP position version mismatch");
+		if (block && block.hash !== page._meta.block.hash) throw new Error("LP history checkpoint changed");
+		block = { hash: page._meta.block.hash };
+		const changes = position.liquidityChanges;
+		const collects = position.collects;
+		events.push(...changes, ...collects.map((event) => ({
+			...event,
+			eventType: "Collect",
+			amountSource: "ExactEvent"
+		})));
+		const lastChange = changes.at(-1);
+		const lastCollect = collects.at(-1);
+		if (lastChange && lastChange.id <= changeCursor || lastCollect && lastCollect.id <= collectCursor) throw new Error("LP history pagination did not advance");
+		changeCursor = lastChange?.id ?? changeCursor;
+		collectCursor = lastCollect?.id ?? collectCursor;
+		if (changes.length < 1e3 && collects.length < 1e3) {
+			events.sort((a, b) => {
+				const order = a.blockNumber - b.blockNumber || a.logIndex - b.logIndex;
+				return order < 0n ? -1 : order > 0n ? 1 : 0;
+			});
+			let held = 0n;
+			for (const event of events) {
+				if (event.eventType === "Collect") continue;
+				held += event.eventType === "Burn" ? -event.liquidity : event.liquidity;
+				if (held < 0n) throw new Error("LP liquidity history is incomplete");
+			}
+			if (held !== position.liquidity || events.length === 0) throw new Error("LP liquidity history is incomplete");
+			return {
+				events,
+				positionId,
+				blockHash: page._meta.block.hash,
+				blockNumber: BigInt(page._meta.block.number),
+				version: position.version
+			};
+		}
+	}
+}
+/** Token flows; v3 collects may include principal already recorded in removals. */
+function summarizeLpPositionHistory(events) {
+	const totals = (eventType) => {
+		let amount0 = 0n;
+		let amount1 = 0n;
+		let estimated = false;
+		for (const event of events) {
+			if (event.eventType !== eventType) continue;
+			if (event.amountSource !== "ExactEvent" && event.amountSource !== "ExactSameTxSwap") {
+				if (event.amountSource !== "ApproxExtsload") return {
+					amount0: null,
+					amount1: null,
+					estimated: false
+				};
+				estimated = true;
+			}
+			amount0 += event.amount0;
+			amount1 += event.amount1;
+		}
+		return {
+			amount0,
+			amount1,
+			estimated
+		};
+	};
+	return {
+		added: totals("Mint"),
+		removed: totals("Burn"),
+		collected: totals("Collect")
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/greeks/positionVolatility.ts
 const Precision$1 = Decimal.clone({ precision: 80 });
@@ -4842,11 +5681,13 @@ function valuePositionAccrual({ snapshots, quoteIsToken0, quoteDecimals }) {
 const Precision = Decimal.clone({ precision: 80 });
 const Q192$1 = (1n << 192n).toString();
 /** Historical convexity and fee coverage at constant LP liquidity, in human quote units. */
-function calculateLpPositionVolatility({ liquidity, tickLower, tickUpper, quoteIsToken0, quoteDecimals, snapshots }) {
+function calculateLpPositionVolatility({ liquidity, tickLower, tickUpper, quoteIsToken0, quoteDecimals, snapshots, observations: priceObservations }) {
 	if (liquidity <= 0n || liquidity >= 1n << 128n) throw new RangeError("Invalid LP liquidity");
 	if (tickLower < -887272n || tickUpper > 887272n || tickLower >= tickUpper) throw new RangeError("Invalid LP range");
+	if (snapshots.some((point, index) => index > 0 && point.blockTimestamp <= snapshots[index - 1].blockTimestamp)) throw new RangeError("Fee snapshots must have increasing timestamps");
 	const scale = new Decimal(10).pow(quoteDecimals);
-	const observations = snapshots.map((snapshot) => ({
+	if (priceObservations && (priceObservations.length < 2 || priceObservations[0].timestamp !== snapshots[0]?.blockTimestamp || priceObservations.at(-1)?.timestamp !== snapshots.at(-1)?.blockTimestamp)) throw new RangeError("Price and fee history must cover the same window");
+	const observations = priceObservations ?? snapshots.map((snapshot) => ({
 		timestamp: snapshot.blockTimestamp,
 		price: quoteIsToken0 ? new Precision(Q192$1).div(new Precision(snapshot.sqrtPriceX96.toString()).pow(2)) : new Precision(snapshot.sqrtPriceX96.toString()).pow(2).div(Q192$1),
 		gamma: new Decimal(getLpGreeks({
@@ -4934,10 +5775,10 @@ function quoteTokenPrices(pools, quoteAddresses) {
 */
 function normalCdf(x) {
 	if (!Number.isFinite(x)) return x > 0 ? 1 : 0;
-	const z = x / Math.SQRT2;
-	const t = 1 / (1 + .3275911 * Math.abs(z));
-	const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - .284496736) * t + .254829592) * t * Math.exp(-z * z);
-	const erf = z >= 0 ? y : -y;
+	const z$1 = x / Math.SQRT2;
+	const t = 1 / (1 + .3275911 * Math.abs(z$1));
+	const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - .284496736) * t + .254829592) * t * Math.exp(-z$1 * z$1);
+	const erf = z$1 >= 0 ? y : -y;
 	return .5 * (1 + erf);
 }
 /**
@@ -5168,104 +6009,21 @@ const V3_SWAP_EXACT_IN = 0;
 const V3_SWAP_EXACT_OUT = 1;
 /**
 * Universal Router recipient sentinel: the router maps `address(1)` to
-* `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
-*/
-const MSG_SENDER = "0x0000000000000000000000000000000000000001";
-const UINT128_MAX$4 = (1n << 128n) - 1n;
-const v3ExactInInputAbi = [
-	{
-		name: "recipient",
-		type: "address"
-	},
-	{
-		name: "amountIn",
-		type: "uint256"
-	},
-	{
-		name: "amountOutMinimum",
-		type: "uint256"
-	},
-	{
-		name: "path",
-		type: "bytes"
-	},
-	{
-		name: "payerIsUser",
-		type: "bool"
-	}
-];
-function assertUint128$1(amount) {
-	if (amount < 0n || amount > UINT128_MAX$4) throw new AmountExceedsUint128Error(amount);
-}
-/**
-* Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
-*/
-function encodeV3Path(tokenIn, fee, tokenOut) {
-	if (fee < 0n || fee > 0xffffffn) throw new PanopticError(`v3 fee ${fee} exceeds uint24`);
-	return encodePacked([
-		"address",
-		"uint24",
-		"address"
-	], [
-		tokenIn,
-		Number(fee),
-		tokenOut
-	]);
-}
-/**
-* Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
-* output is delivered to the `execute` caller (recipient = MSG_SENDER).
-*/
-function buildV3SwapExecuteArgs(args) {
-	const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args;
-	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-in router builder");
-	assertUint128$1(amountIn);
-	assertUint128$1(amountOutMinimum);
-	const path = encodeV3Path(tokenIn, fee, tokenOut);
-	const input = encodeAbiParameters(v3ExactInInputAbi, [
-		MSG_SENDER,
-		amountIn,
-		amountOutMinimum,
-		path,
-		true
-	]);
-	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_IN]);
-	return {
-		args: [
-			commands,
-			[input],
-			deadline
-		],
-		value: 0n
-	};
-}
-/**
-* Build the `execute(commands, inputs, deadline)` calldata for an exact-in
-* single-hop v3 swap.
-*/
-function buildV3SwapExecuteCalldata(args) {
-	const { args: executeArgs, value } = buildV3SwapExecuteArgs(args);
-	const data = encodeFunctionData({
-		abi: universalRouterAbi,
-		functionName: "execute",
-		args: executeArgs
-	});
-	return {
-		data,
-		value
-	};
-}
-const v3ExactOutInputAbi = [
+* `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
+*/
+const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+const UINT128_MAX$4 = (1n << 128n) - 1n;
+const v3ExactInInputAbi = [
 	{
 		name: "recipient",
 		type: "address"
 	},
 	{
-		name: "amountOut",
+		name: "amountIn",
 		type: "uint256"
 	},
 	{
-		name: "amountInMaximum",
+		name: "amountOutMinimum",
 		type: "uint256"
 	},
 	{
@@ -5277,547 +6035,316 @@ const v3ExactOutInputAbi = [
 		type: "bool"
 	}
 ];
+function assertUint128$1(amount) {
+	if (amount < 0n || amount > UINT128_MAX$4) throw new AmountExceedsUint128Error(amount);
+}
 /**
-* Build the typed `execute(...)` args for an exact-out single-hop v3 swap.
-* The v3 exact-out path is reversed: `tokenOut ++ fee ++ tokenIn`.
+* Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
 */
-function buildV3ExactOutSwapExecuteArgs(args) {
-	const { tokenIn, tokenOut, fee, amountOut, amountInMaximum, deadline } = args;
-	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-out router builder");
-	assertUint128$1(amountOut);
-	assertUint128$1(amountInMaximum);
-	const path = encodeV3Path(tokenOut, fee, tokenIn);
-	const input = encodeAbiParameters(v3ExactOutInputAbi, [
+function encodeV3Path(tokenIn, fee, tokenOut) {
+	if (fee < 0n || fee > 0xffffffn) throw new PanopticError(`v3 fee ${fee} exceeds uint24`);
+	return encodePacked([
+		"address",
+		"uint24",
+		"address"
+	], [
+		tokenIn,
+		Number(fee),
+		tokenOut
+	]);
+}
+/**
+* Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
+* output is delivered to the `execute` caller (recipient = MSG_SENDER).
+*/
+function buildV3SwapExecuteArgs(args) {
+	const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args;
+	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-in router builder");
+	assertUint128$1(amountIn);
+	assertUint128$1(amountOutMinimum);
+	const path = encodeV3Path(tokenIn, fee, tokenOut);
+	const input = encodeAbiParameters(v3ExactInInputAbi, [
 		MSG_SENDER,
-		amountOut,
-		amountInMaximum,
+		amountIn,
+		amountOutMinimum,
 		path,
 		true
 	]);
-	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_OUT]);
+	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_IN]);
 	return {
 		args: [
 			commands,
-			[input],
-			deadline
-		],
-		value: 0n
-	};
-}
-function buildV3ExactOutSwapExecuteCalldata(args) {
-	const { args: executeArgs, value } = buildV3ExactOutSwapExecuteArgs(args);
-	const data = encodeFunctionData({
-		abi: universalRouterAbi,
-		functionName: "execute",
-		args: executeArgs
-	});
-	return {
-		data,
-		value
-	};
-}
-
-//#endregion
-//#region src/uniswap/v3/abis/quoterV2.ts
-/**
-* Minimal Uniswap v3 QuoterV2 ABI.
-*
-* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
-* `simulateContract`), so it must be simulated, not read.
-* @module uniswap/v3/abis/quoterV2
-*/
-const quoterV2Abi = [{
-	type: "function",
-	name: "quoteExactInputSingle",
-	stateMutability: "nonpayable",
-	inputs: [{
-		name: "params",
-		type: "tuple",
-		components: [
-			{
-				name: "tokenIn",
-				type: "address"
-			},
-			{
-				name: "tokenOut",
-				type: "address"
-			},
-			{
-				name: "amountIn",
-				type: "uint256"
-			},
-			{
-				name: "fee",
-				type: "uint24"
-			},
-			{
-				name: "sqrtPriceLimitX96",
-				type: "uint160"
-			}
-		]
-	}],
-	outputs: [
-		{
-			name: "amountOut",
-			type: "uint256"
-		},
-		{
-			name: "sqrtPriceX96After",
-			type: "uint160"
-		},
-		{
-			name: "initializedTicksCrossed",
-			type: "uint32"
-		},
-		{
-			name: "gasEstimate",
-			type: "uint256"
-		}
-	]
-}, {
-	type: "function",
-	name: "quoteExactOutputSingle",
-	stateMutability: "nonpayable",
-	inputs: [{
-		name: "params",
-		type: "tuple",
-		components: [
-			{
-				name: "tokenIn",
-				type: "address"
-			},
-			{
-				name: "tokenOut",
-				type: "address"
-			},
-			{
-				name: "amount",
-				type: "uint256"
-			},
-			{
-				name: "fee",
-				type: "uint24"
-			},
-			{
-				name: "sqrtPriceLimitX96",
-				type: "uint160"
-			}
-		]
-	}],
-	outputs: [
-		{
-			name: "amountIn",
-			type: "uint256"
-		},
-		{
-			name: "sqrtPriceX96After",
-			type: "uint160"
-		},
-		{
-			name: "initializedTicksCrossed",
-			type: "uint32"
-		},
-		{
-			name: "gasEstimate",
-			type: "uint256"
-		}
-	]
-}];
-
-//#endregion
-//#region src/uniswap/v3/router/quote.ts
-const BPS_DENOMINATOR$2 = 10000n;
-const UINT128_MAX$3 = (1n << 128n) - 1n;
-/**
-* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
-* pool does not exist / has no liquidity) so callers can skip that pool when
-* ranking venues, rather than aborting the whole cycle.
-*/
-async function quoteV3ExactIn(params) {
-	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
-	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
-	assertSlippageBps$1(slippageBps);
-	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
-	try {
-		const { result } = await client.simulateContract({
-			address: quoterV2,
-			abi: quoterV2Abi,
-			functionName: "quoteExactInputSingle",
-			blockNumber,
-			args: [{
-				tokenIn,
-				tokenOut,
-				amountIn,
-				fee: Number(fee),
-				sqrtPriceLimitX96: 0n
-			}]
-		});
-		const [amountOut, , , gasEstimate] = result;
-		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$2 - slippageBps) / BPS_DENOMINATOR$2;
-		return {
-			amountOut,
-			amountOutMinimum,
-			gasEstimate
-		};
-	} catch (err) {
-		if (isRevert$1(err)) return null;
-		throw err;
-	}
-}
-/**
-* Quote an exact-out v3 swap. Returns `null` on revert (no pool / no liquidity).
-*/
-async function quoteV3ExactOut(params) {
-	const { client, chainId, tokenIn, tokenOut, fee, amountOut, slippageBps, blockNumber } = params;
-	if (amountOut < 0n || amountOut > UINT128_MAX$3) throw new PanopticError(`amountOut ${amountOut} exceeds uint128 maximum`);
-	assertSlippageBps$1(slippageBps);
-	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
-	try {
-		const { result } = await client.simulateContract({
-			address: quoterV2,
-			abi: quoterV2Abi,
-			functionName: "quoteExactOutputSingle",
-			blockNumber,
-			args: [{
-				tokenIn,
-				tokenOut,
-				amount: amountOut,
-				fee: Number(fee),
-				sqrtPriceLimitX96: 0n
-			}]
-		});
-		const [amountIn, , , gasEstimate] = result;
-		const amountInMaximum = (amountIn * (BPS_DENOMINATOR$2 + slippageBps) + BPS_DENOMINATOR$2 - 1n) / BPS_DENOMINATOR$2;
-		return {
-			amountIn,
-			amountInMaximum,
-			gasEstimate
-		};
-	} catch (err) {
-		if (isRevert$1(err)) return null;
-		throw err;
-	}
-}
-function assertSlippageBps$1(slippageBps) {
-	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$2) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
-}
-function isRevert$1(err) {
-	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+			[input],
+			deadline
+		],
+		value: 0n
+	};
 }
-
-//#endregion
-//#region src/panoptic/v2/clients/blockMeta.ts
 /**
-* Get block metadata for a given block.
-* Used to tag all read results with same-block consistency proof.
-*
-* @param params - The parameters
-* @returns Block metadata
+* Build the `execute(commands, inputs, deadline)` calldata for an exact-in
+* single-hop v3 swap.
 */
-async function getBlockMeta(params) {
-	const { client, blockNumber } = params;
-	const block = await client.getBlock({
-		blockNumber,
-		includeTransactions: false
+function buildV3SwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV3SwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
 	});
 	return {
-		blockNumber: block.number,
-		blockHash: block.hash,
-		blockTimestamp: block.timestamp
+		data,
+		value
 	};
 }
-
-//#endregion
-//#region src/panoptic/v2/abis/stateView.ts
-/**
-* Minimal Uniswap V4 StateView ABI for fee growth reads.
-* Only includes functions needed by streamia history.
-*/
-const stateViewAbi = [
+const v3ExactOutInputAbi = [
 	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getSlot0",
-		outputs: [
-			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
-			},
-			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
-			},
-			{
-				internalType: "uint24",
-				name: "protocolFee",
-				type: "uint24"
-			},
-			{
-				internalType: "uint24",
-				name: "lpFee",
-				type: "uint24"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
+		name: "recipient",
+		type: "address"
 	},
 	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getFeeGrowthGlobals",
-		outputs: [{
-			internalType: "uint256",
-			name: "feeGrowthGlobal0",
-			type: "uint256"
-		}, {
-			internalType: "uint256",
-			name: "feeGrowthGlobal1",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
+		name: "amountOut",
+		type: "uint256"
 	},
 	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}, {
-			internalType: "int24",
-			name: "tick",
-			type: "int24"
-		}],
-		name: "getTickInfo",
-		outputs: [
-			{
-				internalType: "uint128",
-				name: "liquidityGross",
-				type: "uint128"
-			},
-			{
-				internalType: "int128",
-				name: "liquidityNet",
-				type: "int128"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside0X128",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside1X128",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
+		name: "amountInMaximum",
+		type: "uint256"
 	},
 	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getLiquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "liquidity",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
+		name: "path",
+		type: "bytes"
+	},
+	{
+		name: "payerIsUser",
+		type: "bool"
 	}
 ];
-
-//#endregion
-//#region src/panoptic/v2/abis/uniswapV3Pool.ts
 /**
-* Minimal Uniswap V3 Pool ABI for fee growth reads.
-* Only includes functions needed by streamia history.
+* Build the typed `execute(...)` args for an exact-out single-hop v3 swap.
+* The v3 exact-out path is reversed: `tokenOut ++ fee ++ tokenIn`.
 */
-const uniswapV3PoolAbi = [
-	{
-		inputs: [],
-		name: "slot0",
-		outputs: [
-			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
-			},
-			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
-			},
-			{
-				internalType: "uint16",
-				name: "observationIndex",
-				type: "uint16"
-			},
-			{
-				internalType: "uint16",
-				name: "observationCardinality",
-				type: "uint16"
-			},
-			{
-				internalType: "uint16",
-				name: "observationCardinalityNext",
-				type: "uint16"
-			},
-			{
-				internalType: "uint8",
-				name: "feeProtocol",
-				type: "uint8"
-			},
-			{
-				internalType: "bool",
-				name: "unlocked",
-				type: "bool"
-			}
+function buildV3ExactOutSwapExecuteArgs(args) {
+	const { tokenIn, tokenOut, fee, amountOut, amountInMaximum, deadline } = args;
+	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-out router builder");
+	assertUint128$1(amountOut);
+	assertUint128$1(amountInMaximum);
+	const path = encodeV3Path(tokenOut, fee, tokenIn);
+	const input = encodeAbiParameters(v3ExactOutInputAbi, [
+		MSG_SENDER,
+		amountOut,
+		amountInMaximum,
+		path,
+		true
+	]);
+	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_OUT]);
+	return {
+		args: [
+			commands,
+			[input],
+			deadline
 		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "feeGrowthGlobal0X128",
-		outputs: [{
-			internalType: "uint256",
-			name: "",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "feeGrowthGlobal1X128",
-		outputs: [{
-			internalType: "uint256",
-			name: "",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "int24",
-			name: "",
-			type: "int24"
-		}],
-		name: "ticks",
-		outputs: [
+		value: 0n
+	};
+}
+function buildV3ExactOutSwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV3ExactOutSwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
+	return {
+		data,
+		value
+	};
+}
+
+//#endregion
+//#region src/uniswap/v3/abis/quoterV2.ts
+/**
+* Minimal Uniswap v3 QuoterV2 ABI.
+*
+* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
+* `simulateContract`), so it must be simulated, not read.
+* @module uniswap/v3/abis/quoterV2
+*/
+const quoterV2Abi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
 			{
-				internalType: "uint128",
-				name: "liquidityGross",
-				type: "uint128"
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				internalType: "int128",
-				name: "liquidityNet",
-				type: "int128"
+				name: "tokenOut",
+				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "feeGrowthOutside0X128",
+				name: "amountIn",
 				type: "uint256"
 			},
 			{
-				internalType: "uint256",
-				name: "feeGrowthOutside1X128",
-				type: "uint256"
+				name: "fee",
+				type: "uint24"
 			},
 			{
-				internalType: "int56",
-				name: "tickCumulativeOutside",
-				type: "int56"
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
+			}
+		]
+	}],
+	outputs: [
+		{
+			name: "amountOut",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}, {
+	type: "function",
+	name: "quoteExactOutputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				internalType: "uint160",
-				name: "secondsPerLiquidityOutsideX128",
-				type: "uint160"
+				name: "tokenOut",
+				type: "address"
 			},
 			{
-				internalType: "uint32",
-				name: "secondsOutside",
-				type: "uint32"
+				name: "amount",
+				type: "uint256"
 			},
 			{
-				internalType: "bool",
-				name: "initialized",
-				type: "bool"
+				name: "fee",
+				type: "uint24"
+			},
+			{
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
 			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "liquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "fee",
-		outputs: [{
-			internalType: "uint24",
-			name: "",
-			type: "uint24"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "token0",
-		outputs: [{
-			internalType: "address",
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "token1",
-		outputs: [{
-			internalType: "address",
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "tickSpacing",
-		outputs: [{
-			internalType: "int24",
-			name: "",
-			type: "int24"
-		}],
-		stateMutability: "view",
-		type: "function"
+		]
+	}],
+	outputs: [
+		{
+			name: "amountIn",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}];
+
+//#endregion
+//#region src/uniswap/v3/router/quote.ts
+const BPS_DENOMINATOR$2 = 10000n;
+const UINT128_MAX$3 = (1n << 128n) - 1n;
+/**
+* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+* pool does not exist / has no liquidity) so callers can skip that pool when
+* ranking venues, rather than aborting the whole cycle.
+*/
+async function quoteV3ExactIn(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
+	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+	assertSlippageBps$1(slippageBps);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactInputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amountIn,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountOut, , , gasEstimate] = result;
+		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$2 - slippageBps) / BPS_DENOMINATOR$2;
+		return {
+			amountOut,
+			amountOutMinimum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert$1(err)) return null;
+		throw err;
 	}
-];
+}
+/**
+* Quote an exact-out v3 swap. Returns `null` on revert (no pool / no liquidity).
+*/
+async function quoteV3ExactOut(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountOut, slippageBps, blockNumber } = params;
+	if (amountOut < 0n || amountOut > UINT128_MAX$3) throw new PanopticError(`amountOut ${amountOut} exceeds uint128 maximum`);
+	assertSlippageBps$1(slippageBps);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactOutputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amount: amountOut,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountIn, , , gasEstimate] = result;
+		const amountInMaximum = (amountIn * (BPS_DENOMINATOR$2 + slippageBps) + BPS_DENOMINATOR$2 - 1n) / BPS_DENOMINATOR$2;
+		return {
+			amountIn,
+			amountInMaximum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert$1(err)) return null;
+		throw err;
+	}
+}
+function assertSlippageBps$1(slippageBps) {
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$2) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
+}
+function isRevert$1(err) {
+	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+}
 
 //#endregion
 //#region src/panoptic/v2/utils/oraclePack.ts
@@ -7792,5 +8319,5 @@ async function swapExactOutViaRouterAndWait(params) {
 }
 
 //#endregion
-export { AmountExceedsUint128Error, InvalidSwapTokenError, LP_RANGE_HORIZONS_DAYS, LP_RANGE_HORIZONS_YEARS, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, calculateLpPositionVolatility, checkRouterApproval, encodeV3Path, estimateLpFees, expectedTimeInRange, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV3PoolBalances, getUniswapV4Addresses, normalCdf, pInRangeAt, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteTokenPrices, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, rangeStats, resolveSwapRoute, resolveV3SwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
+export { AmountExceedsUint128Error, InvalidSwapTokenError, LP_RANGE_HORIZONS_DAYS, LP_RANGE_HORIZONS_YEARS, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, calculateLpPositionVolatility, calculateV3LpAccounting, checkRouterApproval, encodeV3Path, estimateLpFees, expectedTimeInRange, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getLpPositionHistory, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV3PoolBalances, getUniswapV4Addresses, getV3LpHistoryAccounting, normalCdf, pInRangeAt, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteTokenPrices, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, rangeStats, resolveSwapRoute, resolveV3SwapRoute, summarizeLpPositionHistory, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
 //# sourceMappingURL=index.js.map