@panoptic-eng/sdk 1.0.60 → 1.0.62

package/dist/{v2-C3n8n1_i.js → v2-B27ILZl4.js}

@@ -1,9 +1,9 @@
-import { StateViewAbi, getAccountCollateral, panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-BIaLQ-0n.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-COAJpKRd.js";
+import { StateViewAbi, getAccountCollateral, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-BDlcUNgJ.js";
+import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-BwZnK0tG.js";
 import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionGamma, calculatePositionValue, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick } from "./greeks-CNi1-cnp.js";
-import { addLegToTokenId, buildBatchDispatchArgs, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-BTkqc_rn.js";
-import { getLpPositionFunding, getMaxLpPositionSize } from "./router-B2fj4_X7.js";
-import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, hexToString, keccak256, parseAbi, toHex, trim, zeroAddress } from "viem";
+import { addLegToTokenId, buildBatchDispatchArgs, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateDispatch, simulateOpenPosition, simulateWithTokenFlow } from "./writes-B8NGXzUG.js";
+import { getLpPositionFunding, getMaxLpPositionSize } from "./router-Y1OxL9Nt.js";
+import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, hexToString, keccak256, parseAbi, parseEventLogs, toHex, trim, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 import Decimal from "decimal.js";
 
@@ -539,159 +539,6 @@ async function assertLpPositionFunded(params) {
 	return funding;
 }
 
-//#endregion
-//#region src/panoptic/v2/simulations/simulateDispatch.ts
-/**
-* Simulate a raw dispatch operation.
-*
-* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
-* to measure exact collateral asset movements.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with dispatch data or error
-*/
-async function simulateDispatch(params) {
-	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, usePremiaAsCollateral = false, builderCode = 0n, blockNumber, existingPositionIdList, measurePremia = false } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatch",
-			args: [
-				positionIdList,
-				finalPositionIdList,
-				positionSizes,
-				tickAndSpreadLimits.map((t) => [
-					Number(t[0]),
-					Number(t[1]),
-					Number(t[2])
-				]),
-				usePremiaAsCollateral,
-				builderCode
-			]
-		});
-		const preFullPositionsCallData = existingPositionIdList !== void 0 ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				existingPositionIdList
-			]
-		}) : void 0;
-		const prePremiaCallData = measurePremia && existingPositionIdList !== void 0 ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				true,
-				existingPositionIdList
-			]
-		}) : void 0;
-		const postFullPositionsCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				finalPositionIdList
-			]
-		});
-		const postPremiaCallData = measurePremia ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				true,
-				finalPositionIdList
-			]
-		}) : void 0;
-		const flowResult = await simulateWithTokenFlow({
-			client,
-			poolAddress,
-			user: account,
-			callData: params.settleSequence?.targets.length ? encodeFunctionData({
-				abi: panopticPoolV2Abi,
-				functionName: "multicall",
-				args: [[...buildSettleSequenceCalls(params.settleSequence), callData]]
-			}) : callData,
-			blockNumber: targetBlockNumber,
-			preCallData: preFullPositionsCallData ? [preFullPositionsCallData, ...prePremiaCallData ? [prePremiaCallData] : []] : void 0,
-			postCallData: [postFullPositionsCallData, ...postPremiaCallData ? [postPremiaCallData] : []]
-		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
-		const tokenFlow = flowResult.tokenFlow;
-		const preSnapshot = existingPositionIdList ?? [];
-		const positionsCreated = finalPositionIdList.filter((id) => !preSnapshot.includes(id));
-		const positionsClosed = preSnapshot.filter((id) => !finalPositionIdList.includes(id));
-		const decodeFullPositions = (data$1) => {
-			if (!data$1) return null;
-			try {
-				const decoded = decodeFunctionResult({
-					abi: panopticPoolV2Abi,
-					functionName: "getFullPositionsData",
-					data: data$1
-				});
-				const shortPremium = decodeLeftRightUnsigned(decoded[0]);
-				const longPremium = decodeLeftRightUnsigned(decoded[1]);
-				const reqs = decoded[3];
-				let collateralRequirements0 = 0n;
-				let collateralRequirements1 = 0n;
-				for (const packed of reqs) {
-					const r = decodeLeftRightUnsigned(packed);
-					collateralRequirements0 += r.right;
-					collateralRequirements1 += r.left;
-				}
-				return {
-					collateralRequirements0,
-					collateralRequirements1,
-					netPremia0: shortPremium.right - longPremium.right,
-					netPremia1: shortPremium.left - longPremium.left
-				};
-			} catch {
-				return null;
-			}
-		};
-		const prePositions = decodeFullPositions(flowResult.preCallResults?.[0]);
-		const postPositions = decodeFullPositions(flowResult.postCallResults?.[0]);
-		const prePremia = decodeFullPositions(flowResult.preCallResults?.[1]);
-		const postPremia = decodeFullPositions(flowResult.postCallResults?.[1]);
-		const _meta = await metaPromise;
-		const data = {
-			netAmount0: tokenFlow.delta0,
-			netAmount1: tokenFlow.delta1,
-			premiaReceived0: prePremia !== null && postPremia !== null ? prePremia.netPremia0 - postPremia.netPremia0 : null,
-			premiaReceived1: prePremia !== null && postPremia !== null ? prePremia.netPremia1 - postPremia.netPremia1 : null,
-			positionsCreated,
-			positionsClosed,
-			postCollateral0: tokenFlow.balanceAfter0,
-			postCollateral1: tokenFlow.balanceAfter1,
-			preMarginExcess0: prePositions === null ? null : tokenFlow.balanceBefore0 - prePositions.collateralRequirements0,
-			preMarginExcess1: prePositions === null ? null : tokenFlow.balanceBefore1 - prePositions.collateralRequirements1,
-			postMarginExcess0: postPositions === null ? null : tokenFlow.balanceAfter0 - postPositions.collateralRequirements0,
-			postMarginExcess1: postPositions === null ? null : tokenFlow.balanceAfter1 - postPositions.collateralRequirements1
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		return {
-			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Simulation failed", error instanceof Error ? error : void 0),
-			_meta
-		};
-	}
-}
-
 //#endregion
 //#region src/panoptic/v2/simulations/creditWrap.ts
 /**
@@ -3549,6 +3396,73 @@ async function optimizeTokenIdRiskPartners(params) {
 	return optimizedTokenId;
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/tickNetWindows.ts
+/**
+* Wide liquidity distributions from several adjacent `getTickNets*` windows.
+*
+* @module v2/reads/tickNetWindows
+*/
+/** Absolute Uniswap V3/V4 tick bounds. */
+const TICK_MIN$1 = -887272;
+const TICK_MAX$1 = 887272;
+/**
+* Join ascending, edge-sharing windows into one distribution anchored to `windows[mainIndex]`.
+*
+* Each `getTickNets*` window is a running sum of liquidityNet from its own first tick (only the
+* window holding the current tick is rescaled to the pool's liquidity), so a neighbour's values
+* are off by a constant. Adjacent windows share their edge tick; the offset that makes that tick
+* agree is applied to the whole neighbour. Stitching stops at the first window that does not share
+* an edge with the one before it.
+*/
+function stitchTickNetWindows(windows, mainIndex) {
+	const main = windows[mainIndex];
+	if (!main) return {
+		ticks: [],
+		liquidityNets: []
+	};
+	const ticks = [...main.ticks];
+	const nets = [...main.liquidityNets];
+	for (let i = mainIndex + 1; i < windows.length; i++) {
+		const window = windows[i];
+		const edge = ticks.length - 1;
+		if (!window.ticks.length || window.ticks[0] !== ticks[edge]) break;
+		const offset = nets[edge] - window.liquidityNets[0];
+		ticks.push(...window.ticks.slice(1));
+		nets.push(...window.liquidityNets.slice(1).map((value) => value + offset));
+	}
+	for (let i = mainIndex - 1; i >= 0; i--) {
+		const window = windows[i];
+		const last = window.ticks.length - 1;
+		if (last < 0 || window.ticks[last] !== ticks[0]) break;
+		const offset = nets[0] - window.liquidityNets[last];
+		ticks.unshift(...window.ticks.slice(0, last));
+		nets.unshift(...window.liquidityNets.slice(0, last).map((value) => value + offset));
+	}
+	return {
+		ticks,
+		liquidityNets: nets
+	};
+}
+/**
+* Read the main window around `startTick` plus up to `windowsPerSide` windows of `nTicks` on each
+* side, in parallel, and stitch them. Side windows that would cross the tick bounds are skipped.
+*/
+async function readTickNetWindows({ startTick, mainNTicks, nTicks, tickSpacing, windowsPerSide, read }) {
+	const center = Math.trunc(startTick / tickSpacing) * tickSpacing;
+	const half = Number(nTicks) * tickSpacing;
+	const mainHalf = Number(mainNTicks) * tickSpacing;
+	const sideCenters = (direction) => Array.from({ length: windowsPerSide }, (_, k) => center + direction * (mainHalf + half + 2 * half * k)).filter((side) => side - half >= TICK_MIN$1 && side + half <= TICK_MAX$1);
+	const below = sideCenters(-1).reverse();
+	const above = sideCenters(1);
+	const windows = await Promise.all([
+		...below.map((side) => read(side, nTicks)),
+		read(startTick, mainNTicks),
+		...above.map((side) => read(side, nTicks))
+	]);
+	return stitchTickNetWindows(windows, below.length);
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/liquidity.ts
 /**
@@ -3566,24 +3480,35 @@ async function optimizeTokenIdRiskPartners(params) {
 async function getPoolLiquidities(params) {
 	const { client, poolAddress, queryAddress, startTick, nTicks, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
-	const [result, _meta] = await Promise.all([client.readContract({
-		address: queryAddress,
-		abi: panopticQueryAbi,
-		functionName: "getTickNets",
-		args: [
-			poolAddress,
-			Number(startTick),
-			nTicks
-		],
-		blockNumber: targetBlockNumber
+	const windowsPerSide = params.windowsPerSide ?? 0;
+	if (windowsPerSide > 0 && params.tickSpacing === void 0) throw new PanopticValidationError("getPoolLiquidities: tickSpacing is required with windowsPerSide");
+	const [{ ticks, liquidityNets }, _meta] = await Promise.all([readTickNetWindows({
+		startTick: Number(startTick),
+		mainNTicks: nTicks,
+		nTicks,
+		tickSpacing: params.tickSpacing ?? 1,
+		windowsPerSide,
+		read: (centerTick, windowTicks) => client.readContract({
+			address: queryAddress,
+			abi: panopticQueryAbi,
+			functionName: "getTickNets",
+			args: [
+				poolAddress,
+				centerTick,
+				windowTicks
+			],
+			blockNumber: targetBlockNumber
+		}).then(([tickData, nets]) => ({
+			ticks: tickData,
+			liquidityNets: nets
+		}))
 	}), params._meta ?? getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	})]);
-	const [tickData, liquidityNets] = result;
 	return {
-		ticks: [...tickData],
-		liquidityNets: [...liquidityNets],
+		ticks,
+		liquidityNets,
 		_meta
 	};
 }
@@ -4475,6 +4400,32 @@ function computeUniswapFeesForBlock(blockData, legs) {
 		total1
 	};
 }
+const MAX_UINT256$1 = 2n ** 256n - 1n;
+/**
+* Fee growth per unit of liquidity inside `[lowerTick, upperTick)` at one block,
+* wrapped to uint256 as the pool computes it. Diff two snapshots with
+* `feesFromFeeGrowthDelta` to get the fees a constant liquidity earned between them.
+*/
+function feeGrowthInsideX128(blockData, lowerTick, upperTick) {
+	const lower = blockData.tickData.get(lowerTick);
+	const upper = blockData.tickData.get(upperTick);
+	if (!lower || !upper) return null;
+	const { currentTick } = blockData;
+	const inside = (global, lowerOutside, upperOutside) => {
+		const below = currentTick >= lowerTick ? lowerOutside : global - lowerOutside;
+		const above = currentTick < upperTick ? upperOutside : global - upperOutside;
+		return global - below - above & MAX_UINT256$1;
+	};
+	return {
+		feeGrowthInside0X128: inside(blockData.feeGrowthGlobal0, lower.feeGrowthOutside0, upper.feeGrowthOutside0),
+		feeGrowthInside1X128: inside(blockData.feeGrowthGlobal1, lower.feeGrowthOutside1, upper.feeGrowthOutside1)
+	};
+}
+/** Blocks before the chain's Multicall3 deployment need viem's deployless multicall. */
+function predatesMulticall3(client, blockNumber) {
+	const deployedAt = client.chain?.contracts?.multicall3?.blockCreated;
+	return blockNumber != null && deployedAt != null && blockNumber < BigInt(deployedAt);
+}
 async function fetchUniswapBlockSnapshot(client, blockNumber, uniqueTicks, poolConfig) {
 	if (poolConfig.version === "v3") return fetchV3BlockSnapshot(client, poolConfig.poolAddress, blockNumber, uniqueTicks);
 	else return fetchV4BlockSnapshot(client, poolConfig.stateViewAddress, poolConfig.poolId, blockNumber, uniqueTicks);
@@ -4506,7 +4457,8 @@ async function fetchV3BlockSnapshot(client, poolAddress, blockNumber, uniqueTick
 	const results = await client.multicall({
 		contracts,
 		blockNumber,
-		allowFailure: false
+		allowFailure: false,
+		deployless: predatesMulticall3(client, blockNumber)
 	});
 	const slot0Result = results[0];
 	const feeGrowthGlobal0 = results[1];
@@ -4515,6 +4467,7 @@ async function fetchV3BlockSnapshot(client, poolAddress, blockNumber, uniqueTick
 	for (let i = 0; i < uniqueTicks.length; i++) {
 		const tickResult = results[3 + i];
 		tickData.set(uniqueTicks[i], {
+			liquidityGross: tickResult[0],
 			feeGrowthOutside0: tickResult[2],
 			feeGrowthOutside1: tickResult[3]
 		});
@@ -4551,7 +4504,8 @@ async function fetchV4BlockSnapshot(client, stateViewAddress, poolId, blockNumbe
 	const results = await client.multicall({
 		contracts,
 		blockNumber,
-		allowFailure: false
+		allowFailure: false,
+		deployless: predatesMulticall3(client, blockNumber)
 	});
 	const slot0Result = results[0];
 	const feeGrowthResult = results[1];
@@ -4559,6 +4513,7 @@ async function fetchV4BlockSnapshot(client, stateViewAddress, poolId, blockNumbe
 	for (let i = 0; i < uniqueTicks.length; i++) {
 		const tickResult = results[2 + i];
 		tickData.set(uniqueTicks[i], {
+			liquidityGross: tickResult[0],
 			feeGrowthOutside0: tickResult[2],
 			feeGrowthOutside1: tickResult[3]
 		});
@@ -4861,23 +4816,34 @@ function clampNTicks(startTick, tickSpacing, nTicks) {
 * for the pool — only a deployed PanopticQuery on the chain.
 */
 async function getUniswapV3PoolLiquidities(params) {
-	const { client, poolAddress, queryAddress, startTick, nTicks } = params;
-	const safeN = clampNTicks(startTick, 1, nTicks);
+	const { client, poolAddress, queryAddress, startTick, nTicks, windowsPerSide = 0 } = params;
+	if (windowsPerSide > 0 && params.tickSpacing === void 0) throw new PanopticValidationError("getUniswapV3PoolLiquidities: tickSpacing is required with windowsPerSide");
+	const safeN = clampNTicks(startTick, params.tickSpacing ?? 1, nTicks);
 	const _meta = await getBlockMeta({ client });
-	const [ticks, liquidityNets] = await client.readContract({
-		address: queryAddress,
-		abi: panopticQueryAbi,
-		functionName: "getTickNetsV3",
-		args: [
-			poolAddress,
-			startTick,
-			safeN
-		],
-		blockNumber: _meta.blockNumber
+	const { ticks, liquidityNets } = await readTickNetWindows({
+		startTick,
+		mainNTicks: safeN,
+		nTicks,
+		tickSpacing: params.tickSpacing ?? 1,
+		windowsPerSide,
+		read: (centerTick, windowTicks) => client.readContract({
+			address: queryAddress,
+			abi: panopticQueryAbi,
+			functionName: "getTickNetsV3",
+			args: [
+				poolAddress,
+				centerTick,
+				windowTicks
+			],
+			blockNumber: _meta.blockNumber
+		}).then(([windowTickData, windowNets]) => ({
+			ticks: windowTickData,
+			liquidityNets: windowNets
+		}))
 	});
 	return {
-		ticks: [...ticks],
-		liquidityNets: [...liquidityNets],
+		ticks,
+		liquidityNets,
 		_meta
 	};
 }
@@ -5050,22 +5016,32 @@ async function getUniswapV4PoolLiquidities(params) {
 	const { client, queryAddress, poolManager, poolId, tickSpacing, startTick, nTicks } = params;
 	const safeN = clampNTicks(startTick, tickSpacing, nTicks);
 	const _meta = await getBlockMeta({ client });
-	const [ticks, liquidityNets] = await client.readContract({
-		address: queryAddress,
-		abi: panopticQueryAbi,
-		functionName: "getTickNetsV4",
-		args: [
-			poolManager,
-			poolId,
-			tickSpacing,
-			startTick,
-			safeN
-		],
-		blockNumber: _meta.blockNumber
+	const { ticks, liquidityNets } = await readTickNetWindows({
+		startTick,
+		mainNTicks: safeN,
+		nTicks,
+		tickSpacing,
+		windowsPerSide: params.windowsPerSide ?? 0,
+		read: (centerTick, windowTicks) => client.readContract({
+			address: queryAddress,
+			abi: panopticQueryAbi,
+			functionName: "getTickNetsV4",
+			args: [
+				poolManager,
+				poolId,
+				tickSpacing,
+				centerTick,
+				windowTicks
+			],
+			blockNumber: _meta.blockNumber
+		}).then(([windowTickData, windowNets]) => ({
+			ticks: windowTickData,
+			liquidityNets: windowNets
+		}))
 	});
 	return {
-		ticks: [...ticks],
-		liquidityNets: [...liquidityNets],
+		ticks,
+		liquidityNets,
 		_meta
 	};
 }
@@ -9927,6 +9903,131 @@ function marketRiskFromValues({ lower, current, upper }) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/greeks/positionVolatility.ts
+const Precision = Decimal.clone({ precision: 80 });
+const Q96 = 1n << 96n;
+const YEAR_SECONDS = new Precision(31536e3);
+/** The premium-free position curve, expressed in one quote token's human units. */
+function preparePositionGamma({ tokenId, positionSize, quoteIsToken0, quoteDecimals }) {
+	if (positionSize <= 0n || positionSize >= 1n << 128n) throw new RangeError("Invalid position size");
+	if (!Number.isInteger(quoteDecimals) || quoteDecimals < 0 || quoteDecimals > 255) throw new RangeError("Invalid quote decimals");
+	const decoded = decodeTokenId(tokenId);
+	const chunks = decoded.legs.flatMap((leg) => {
+		if (leg.width === 0n) return [];
+		const width = leg.width * decoded.tickSpacing;
+		const lowerTick = leg.strike - width / 2n;
+		const upperTick = leg.strike + (width + 1n) / 2n;
+		if (lowerTick < -887272n || upperTick > 887272n || lowerTick >= upperTick) throw new RangeError("Invalid position range");
+		const lower = tickToSqrtPriceX96(lowerTick);
+		const upper = tickToSqrtPriceX96(upperTick);
+		const amount = positionSize * leg.optionRatio;
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96) / (upper - lower) : amount * Q96 / (upper - lower);
+		if (liquidity >= 1n << 128n) throw new RangeError("Liquidity exceeds uint128");
+		return [{
+			lowerTick: Number(lowerTick),
+			upperTick: Number(upperTick),
+			liquidity,
+			isLong: leg.isLong
+		}];
+	});
+	const scale = new Precision(10).pow(quoteDecimals);
+	const atTick = (tick) => {
+		const netLiquidity = chunks.reduce((sum$1, chunk) => tick >= BigInt(chunk.lowerTick) && tick < BigInt(chunk.upperTick) ? sum$1 + (chunk.isLong ? -chunk.liquidity : chunk.liquidity) : sum$1, 0n);
+		const sqrt = new Precision(tickToSqrtPriceX96(tick).toString()).div(Q96.toString());
+		const gamma = new Precision(netLiquidity.toString()).neg().div(2).div(scale);
+		return quoteIsToken0 ? gamma.div(sqrt) : gamma.mul(sqrt);
+	};
+	const inRange = (low, high) => {
+		if (low > high) throw new RangeError("Invalid candle range");
+		const ticks = new Set([low, high]);
+		for (const chunk of chunks) for (const boundary of [BigInt(chunk.lowerTick), BigInt(chunk.upperTick)]) {
+			if (boundary >= low && boundary <= high) ticks.add(boundary);
+			if (boundary - 1n >= low && boundary - 1n <= high) ticks.add(boundary - 1n);
+		}
+		return [...ticks].map(atTick);
+	};
+	return {
+		chunks,
+		atTick,
+		inRange
+	};
+}
+/** Historical whole-position diagnostics, with signs retained independently of eligibility. */
+function calculatePositionVolatilityMetrics({ observations, netPremium, baseFees, quoteDecimals }) {
+	if (observations.length < 2) throw new RangeError("At least two price observations are required");
+	if (!Number.isInteger(quoteDecimals) || quoteDecimals < 0 || quoteDecimals > 255) throw new RangeError("Invalid quote decimals");
+	const points = observations.map((point) => ({
+		...point,
+		price: new Precision(point.price),
+		gamma: new Precision(point.gamma),
+		rangeGammas: (point.rangeGammas ?? []).map((gamma) => new Precision(gamma))
+	}));
+	for (const point of points) if (!point.price.isFinite() || point.price.lte(0) || !point.gamma.isFinite() || point.rangeGammas.some((gamma) => !gamma.isFinite())) throw new RangeError("Invalid price or gamma observation");
+	const quantum = new Precision(10).pow(-quoteDecimals);
+	const gammas = points.flatMap((point) => [point.gamma, ...point.rangeGammas]);
+	const peak = gammas.reduce((max, gamma) => Precision.max(max, gamma.abs()), new Precision(0));
+	const tolerance = Precision.max(quantum, peak.mul("1e-12"));
+	const positive = gammas.some((gamma) => gamma.gt(tolerance));
+	const negative = gammas.some((gamma) => gamma.lt(tolerance.neg()));
+	const gammaSign = positive && negative ? "changing" : positive ? "positive" : negative ? "negative" : "zero";
+	let exposure = new Precision(0);
+	let signedConvexity = new Precision(0);
+	let absoluteConvexity = new Precision(0);
+	let years = new Precision(0);
+	for (let i = 1; i < points.length; i++) {
+		const previous = points[i - 1];
+		const point = points[i];
+		const seconds = point.timestamp - previous.timestamp;
+		if (seconds <= 0n) throw new RangeError("Observations must have increasing timestamps");
+		const elapsed = new Precision(seconds.toString()).div(YEAR_SECONDS);
+		const squaredReturn = point.price.div(previous.price).ln().pow(2);
+		exposure = exposure.plus(previous.gamma.abs().mul(elapsed));
+		signedConvexity = signedConvexity.plus(previous.gamma.mul(squaredReturn).div(2));
+		absoluteConvexity = absoluteConvexity.plus(previous.gamma.abs().mul(squaredReturn).div(2));
+		years = years.plus(elapsed);
+	}
+	const sufficientExposure = exposure.gt(tolerance.mul(years).mul(100));
+	const premium = netPremium === null ? null : new Precision(netPremium);
+	const fees = baseFees == null ? null : new Precision(baseFees);
+	if (premium !== null && !premium.isFinite() || fees !== null && !fees.isFinite()) throw new RangeError("Invalid accounting amount");
+	const consistent = (amount) => gammaSign === "positive" ? amount.lte(quantum) : gammaSign === "negative" && amount.gte(quantum.neg());
+	const reason = !sufficientExposure ? "insufficient-exposure" : gammaSign === "changing" ? "changing-sign" : premium === null ? "premium-unavailable" : !consistent(premium) ? "inconsistent-premium-direction" : null;
+	const equivalent = (amount) => amount.abs().mul(2).div(exposure).sqrt().toString();
+	const coverage = (amount) => absoluteConvexity.gt(quantum) ? amount.abs().div(absoluteConvexity).toString() : null;
+	const eligibleFees = sufficientExposure && fees !== null && consistent(fees);
+	return {
+		gammaSign,
+		exposure: exposure.toString(),
+		signedConvexity: signedConvexity.toString(),
+		absoluteConvexity: absoluteConvexity.toString(),
+		netPremium: premium?.toString() ?? null,
+		estimatedHedgedResult: premium?.plus(signedConvexity).toString() ?? null,
+		weightedRealizedVolatility: sufficientExposure ? equivalent(absoluteConvexity) : null,
+		premiumEquivalentVolatility: reason === null && premium !== null ? equivalent(premium) : null,
+		premiumToConvexity: reason === null && premium !== null ? coverage(premium) : null,
+		baseFees: fees?.toString() ?? null,
+		feeEquivalentVolatility: eligibleFees ? equivalent(fees) : null,
+		feeToConvexity: eligibleFees ? coverage(fees) : null,
+		comparisonReason: reason
+	};
+}
+/** Quote-value signed cumulative token increments, excluding revaluation of previous accrual. */
+function valuePositionAccrual({ snapshots, quoteIsToken0, quoteDecimals }) {
+	let previous0 = 0n;
+	let previous1 = 0n;
+	let total = new Precision(0);
+	for (const snapshot of snapshots) {
+		const amount0 = new Precision((snapshot.token0 - previous0).toString());
+		const amount1 = new Precision((snapshot.token1 - previous1).toString());
+		const price = new Precision("1.0001").pow(snapshot.tick.toString());
+		total = total.plus(quoteIsToken0 ? amount0.plus(amount1.div(price)) : amount1.plus(amount0.mul(price)));
+		previous0 = snapshot.token0;
+		previous1 = snapshot.token1;
+	}
+	return total.div(new Precision(10).pow(quoteDecimals));
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/collateralCurve.ts
 /** Native-token margin inputs, independent of the tick used to display the curve. */
@@ -10120,4 +10221,219 @@ function preparePositionValueCurve(curve) {
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolCollateralAddresses, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionValueCurve, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionValueCurve, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, watchEvents };
+//#region src/panoptic/v2/reads/positionVolatilityHistory.ts
+const signedSlot = (value) => BigInt.asIntN(128, value);
+const unpack = (value) => ({
+	token0: signedSlot(value),
+	token1: signedSlot(value >> 128n)
+});
+/** RPC accounting for exactly one mint lifecycle; candle prices are supplied by the application. */
+async function getPositionVolatilityHistory({ client, poolAddress, account, tokenId, mintBlock, endBlock, poolConfig, includeBaseFees = false }) {
+	if (mintBlock <= 0n || endBlock <= mintBlock) throw new RangeError("Insufficient lifecycle history");
+	const [mints, burns] = await Promise.all([client.getContractEvents({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		eventName: "OptionMinted",
+		args: {
+			recipient: account,
+			tokenId
+		},
+		fromBlock: mintBlock,
+		toBlock: mintBlock,
+		strict: true
+	}), client.getContractEvents({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		eventName: "OptionBurnt",
+		args: {
+			recipient: account,
+			tokenId
+		},
+		fromBlock: mintBlock,
+		toBlock: endBlock,
+		strict: true
+	})]);
+	const mint = mints[0];
+	if (mints.length !== 1 || !mint) throw new Error("Opening event is missing or ambiguous");
+	const balance = decodePositionBalance(mint.args.balanceData);
+	const close = burns.filter((burn) => burn.blockNumber > mintBlock || burn.logIndex > mint.logIndex).sort((a, b) => a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1)[0];
+	const finalBlock = close?.blockNumber ?? endBlock;
+	if (finalBlock <= mintBlock) throw new Error("Intrablock lifecycle cannot be reconstructed");
+	if (close && close.args.positionSize !== balance.positionSize) throw new Error("Position size changed");
+	const [start, end, boundaryPrices] = await Promise.all([
+		getBlockMeta({
+			client,
+			blockNumber: mintBlock
+		}),
+		getBlockMeta({
+			client,
+			blockNumber: finalBlock
+		}),
+		getPriceHistory({
+			client,
+			poolConfig,
+			blockNumbers: [mintBlock, finalBlock]
+		})
+	]);
+	const openingPrice = boundaryPrices.snapshots[0];
+	const endingPrice = boundaryPrices.snapshots[1];
+	if (!openingPrice || !endingPrice) throw new Error("Boundary prices unavailable");
+	const pointCount = Math.min(200, Math.max(2, Number((end.blockTimestamp - start.blockTimestamp) / 900n) + 2));
+	const blockNumbers = [...new Set(interpolateBlocks(mintBlock, finalBlock, pointCount))];
+	const metadata = [];
+	for (let i = 0; i < blockNumbers.length; i += 16) metadata.push(...await Promise.all(blockNumbers.slice(i, i + 16).map((blockNumber) => getBlockMeta({
+		client,
+		blockNumber
+	}))));
+	const timestamps = new Map(metadata.map((meta) => [meta.blockNumber, meta.blockTimestamp]));
+	const chunks = preparePositionGamma({
+		tokenId,
+		positionSize: balance.positionSize,
+		quoteIsToken0: false,
+		quoteDecimals: 0
+	}).chunks.filter((chunk) => chunk.liquidity > 0n);
+	let premiumError = null;
+	let feeError = includeBaseFees ? null : "Base fee history was not requested";
+	let premium = null;
+	let fees = null;
+	try {
+		const settlementLogs = await client.getContractEvents({
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			eventName: "PremiumSettled",
+			args: {
+				user: account,
+				tokenId
+			},
+			fromBlock: mintBlock,
+			toBlock: finalBlock,
+			strict: true
+		});
+		const settled = [];
+		const seen = new Set();
+		for (const log of settlementLogs) {
+			if (log.blockNumber === mintBlock && log.logIndex <= mint.logIndex) continue;
+			if (close && log.blockNumber === finalBlock && log.logIndex >= close.logIndex) continue;
+			const key = `${log.transactionHash}:${log.logIndex}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const amounts = unpack(log.args.settledAmounts);
+			settled.push({
+				blockNumber: log.blockNumber,
+				settled0: amounts.token0,
+				settled1: amounts.token1
+			});
+		}
+		if (close) {
+			const receipt = await client.getTransactionReceipt({ hash: close.transactionHash });
+			const liquidations = parseEventLogs({
+				abi: panopticPoolV2Abi,
+				logs: receipt.logs.filter((log) => log.address.toLowerCase() === poolAddress.toLowerCase()),
+				eventName: "AccountLiquidated"
+			});
+			if (liquidations.some((event) => event.args.liquidatee.toLowerCase() === account.toLowerCase())) throw new Error("Liquidation premium requires haircut reconciliation");
+			for (const packed of close.args.premiaByLeg) {
+				const amounts = unpack(packed);
+				settled.push({
+					blockNumber: finalBlock,
+					settled0: amounts.token0,
+					settled1: amounts.token1
+				});
+			}
+		}
+		const readableBlocks = close ? blockNumbers.filter((block) => block < finalBlock) : blockNumbers;
+		premium = [];
+		for (let i = 0; i < readableBlocks.length; i += 16) {
+			const history = await getStreamiaHistory({
+				client,
+				panopticPoolAddress: poolAddress,
+				account,
+				tokenId,
+				blockNumbers: readableBlocks.slice(i, i + 16),
+				legs: [],
+				poolConfig,
+				includeUniswapFees: false,
+				settledEvents: settled,
+				_meta: end
+			});
+			for (const snapshot of history.snapshots) {
+				const timestamp = snapshot.blockNumber === void 0 ? void 0 : timestamps.get(snapshot.blockNumber);
+				if (timestamp === void 0) throw new Error("Accounting timestamp missing");
+				premium.push({
+					timestamp,
+					...snapshot.cumulativePanopticPremia
+				});
+			}
+		}
+		if (close) premium.push({
+			timestamp: end.blockTimestamp,
+			...settled.reduce((sum$1, event) => ({
+				token0: sum$1.token0 + event.settled0,
+				token1: sum$1.token1 + event.settled1
+			}), {
+				token0: 0n,
+				token1: 0n
+			})
+		});
+		const openingAccrual = premium[0];
+		if (!openingAccrual || openingAccrual.timestamp !== start.blockTimestamp) throw new Error("Opening premium snapshot missing");
+		premium = premium.map((snapshot) => ({
+			timestamp: snapshot.timestamp,
+			token0: snapshot.token0 - openingAccrual.token0,
+			token1: snapshot.token1 - openingAccrual.token1
+		}));
+	} catch (error) {
+		premium = null;
+		premiumError = error instanceof Error ? error.message : "Premium history unavailable";
+	}
+	if (includeBaseFees) try {
+		const feeBlocks = close ? blockNumbers.filter((block) => block < finalBlock) : blockNumbers;
+		const data = [];
+		for (let i = 0; i < feeBlocks.length; i += 16) data.push(...await fetchUniswapFeeData(client, feeBlocks.slice(i, i + 16), chunks, poolConfig));
+		let total0 = 0n;
+		let total1 = 0n;
+		fees = [];
+		for (let i = 0; i < data.length; i++) {
+			const current = data[i];
+			for (const chunk of chunks) {
+				if ((current.tickData.get(chunk.lowerTick)?.liquidityGross ?? 0n) === 0n || (current.tickData.get(chunk.upperTick)?.liquidityGross ?? 0n) === 0n) throw new Error("LP range was uninitialized; complete base fee history is unavailable");
+				if (i === 0) continue;
+				const previous = feeGrowthInsideX128(data[i - 1], chunk.lowerTick, chunk.upperTick);
+				const next = feeGrowthInsideX128(current, chunk.lowerTick, chunk.upperTick);
+				if (!previous || !next) throw new Error("Range fee growth missing");
+				if (BigInt.asUintN(256, next.feeGrowthInside0X128 - previous.feeGrowthInside0X128) > BigInt.asUintN(256, current.feeGrowthGlobal0 - data[i - 1].feeGrowthGlobal0) || BigInt.asUintN(256, next.feeGrowthInside1X128 - previous.feeGrowthInside1X128) > BigInt.asUintN(256, current.feeGrowthGlobal1 - data[i - 1].feeGrowthGlobal1)) throw new Error("Range fee growth is inconsistent with pool fee growth");
+				const sign = chunk.isLong ? -1n : 1n;
+				total0 += sign * feesFromFeeGrowthDelta(next.feeGrowthInside0X128, previous.feeGrowthInside0X128, chunk.liquidity);
+				total1 += sign * feesFromFeeGrowthDelta(next.feeGrowthInside1X128, previous.feeGrowthInside1X128, chunk.liquidity);
+			}
+			fees.push({
+				timestamp: metadata[i].blockTimestamp,
+				token0: total0,
+				token1: total1
+			});
+		}
+	} catch (error) {
+		fees = null;
+		feeError = error instanceof Error ? error.message : "Base fee history unavailable";
+	}
+	return {
+		start,
+		end,
+		positionSize: balance.positionSize,
+		closed: close !== void 0,
+		openingTick: BigInt(openingPrice.tick),
+		endingTick: BigInt(endingPrice.tick),
+		premium,
+		fees,
+		premiumError,
+		feeError,
+		accountingSamples: blockNumbers.length,
+		maxAccountingIntervalSeconds: metadata.slice(1).reduce((maximum, meta, index) => {
+			const interval = meta.blockTimestamp - metadata[index].blockTimestamp;
+			return interval > maximum ? interval : maximum;
+		}, 0n)
+	};
+}
+
+//#endregion
+export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculatePositionVolatilityMetrics, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feeGrowthInsideX128, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, fetchUniswapFeeData, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolCollateralAddresses, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionValueCurve, getPositionVolatilityHistory, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionGamma, preparePositionValueCurve, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, valuePositionAccrual, watchEvents };