@panoptic-eng/sdk 1.0.60 → 1.0.62

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

@@ -1,4 +1,4 @@
-import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, getAddress, hexToString, isAddressEqual, keccak256, maxUint256, parseAbi, stringToHex, toFunctionSelector, toHex, trim, zeroAddress } from "viem";
+import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, getAddress, hexToString, isAddressEqual, keccak256, maxUint256, parseAbi, parseEventLogs, stringToHex, toFunctionSelector, toHex, trim, zeroAddress } from "viem";
 import { call, multicall } from "viem/actions";
 import Decimal from "decimal.js";
 import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
@@ -9400,6 +9400,10 @@ function extractErrorData(error) {
 		error.walk((e) => {
 			if (foundData) return false;
 			const node = e;
+			if (typeof node.raw === "string" && node.raw.startsWith("0x") && node.raw.length > 10) {
+				foundData = node.raw;
+				return true;
+			}
 			if (node.data && typeof node.data === "string" && node.data.startsWith("0x")) {
 				foundData = node.data;
 				return true;
@@ -9428,6 +9432,7 @@ function extractErrorData(error) {
 	let current = error;
 	const maxDepth = 10;
 	for (let i = 0; i < maxDepth && current; i++) {
+		if (typeof current.raw === "string" && current.raw.startsWith("0x") && current.raw.length > 10) return current.raw;
 		if (current.data && typeof current.data === "string" && current.data.startsWith("0x")) return current.data;
 		if (current.data && typeof current.data === "object") {
 			const nested = current.data;
@@ -9441,7 +9446,7 @@ function extractErrorData(error) {
 	}
 	const obj = error;
 	if (obj.message && typeof obj.message === "string") {
-		const signatureMatch = obj.message.match(/signature:\s*(0x[a-fA-F0-9]{8,})/i);
+		const signatureMatch = obj.message.match(/signature:?\s*["']?(0x[a-fA-F0-9]{8,})/i);
 		if (signatureMatch) return signatureMatch[1];
 	}
 	return null;
@@ -11112,12 +11117,12 @@ function generateOverlappingTokenIds(params) {
 //#region src/panoptic/v2/tokenId/split.ts
 const POOL_ID_MASK$3 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
 const MAX_UINT128$3 = (1n << 128n) - 1n;
-const MAX_UINT256$1 = (1n << 256n) - 1n;
+const MAX_UINT256$2 = (1n << 256n) - 1n;
 function invalid(message) {
 	throw new PanopticValidationError(`splitTokenIdByTimescale: ${message}`);
 }
 function validateInput(tokenId, positionSize) {
-	if (tokenId < 0n || tokenId > MAX_UINT256$1) invalid("tokenId must fit in uint256");
+	if (tokenId < 0n || tokenId > MAX_UINT256$2) invalid("tokenId must fit in uint256");
 	if (positionSize <= 0n || positionSize > MAX_UINT128$3) invalid("positionSize must be between 1 and uint128.max");
 	const legs = decodeAllLegs(tokenId);
 	if (legs.length === 0) invalid("tokenId must contain at least one active leg");
@@ -11272,7 +11277,7 @@ function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
 
 //#endregion
 //#region src/uniswap/lpDeposit.ts
-const Q96$2 = 1n << 96n;
+const Q96$3 = 1n << 96n;
 const ceilDiv$4 = (n, d) => (n + d - 1n) / d;
 /** Principal and separately identified funding headroom, in native token units. */
 function getLpDepositBreakdown(ranges, sqrtPriceX96) {
@@ -11284,8 +11289,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$4(liquidity * Q96$2 * (upper - price), upper * price);
-		amount1 += ceilDiv$4(liquidity * (price - lower), Q96$2);
+		amount0 += ceilDiv$4(liquidity * Q96$3 * (upper - price), upper * price);
+		amount1 += ceilDiv$4(liquidity * (price - lower), Q96$3);
 	}
 	const buffer = {
 		amount0: ceilDiv$4(amount0 * 5n, 100n),
@@ -11313,7 +11318,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$2) / (upper - lower) : amount * Q96$2 / (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),
@@ -11334,7 +11339,7 @@ function getLpPositionFunding(params) {
 	});
 	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
 	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
-	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$4(amount1 * Q96$2 * Q96$2, priceSquared) : amount1 + ceilDiv$4(amount0 * priceSquared, Q96$2 * Q96$2);
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$4(amount1 * Q96$3 * Q96$3, priceSquared) : amount1 + ceilDiv$4(amount0 * priceSquared, Q96$3 * Q96$3);
 	const principalInQuote = value(breakdown.principal);
 	const totalInQuote = value(breakdown.total);
 	return {
@@ -12740,6 +12745,17 @@ function createTxResult(client, hash) {
 * @returns TxResult
 */
 async function submitWrite(params) {
+	try {
+		return await submitWriteRequest({
+			...params,
+			abi: [...params.abi, ...panopticErrorsAbi]
+		});
+	} catch (error) {
+		if (error instanceof PanopticError) throw error;
+		throw parsePanopticError(error)?.error ?? error;
+	}
+}
+async function submitWriteRequest(params) {
 	const { client, walletClient, account, address, abi: abi$1, functionName, args, value, txOverrides } = params;
 	const broadcaster = txOverrides?.broadcaster;
 	if (broadcaster) {
@@ -14467,7 +14483,7 @@ async function assertLpPositionFunded(params) {
 //#endregion
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
-const Q96$1 = 1n << 96n;
+const Q96$2 = 1n << 96n;
 const Q192$3 = 1n << 192n;
 /**
 * Convert tick to quote-denominated tick based on asset direction.
@@ -14615,7 +14631,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 	const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const rX192 = sqrtR * sqrtR;
-	const sqrtKPmX96 = divTrunc(sqrtK * Q96$1, sqrtPm);
+	const sqrtKPmX96 = divTrunc(sqrtK * Q96$2, sqrtPm);
 	const diff = sqrtR - sqrtKPmX96;
 	const diffSqX192 = diff * diff;
 	return divTrunc(m * diffSqX192, rX192 - Q192$3);
@@ -14687,7 +14703,7 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 		const PX192 = sqrtP * sqrtP;
 		const KX192 = sqrtK * sqrtK;
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (2n * sqrtPKR * Q96$1 - PX192 - KX192);
+		const numerator = m * (2n * sqrtPKR * Q96$2 - PX192 - KX192);
 		const denominator = rX192 - Q192$3;
 		v = divTrunc(numerator, denominator);
 	}
@@ -14795,7 +14811,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const rX192 = sqrtR * sqrtR;
-			const sqrtKPmX96 = sqrtK * Q96$1 / sqrtPm;
+			const sqrtKPmX96 = sqrtK * Q96$2 / sqrtPm;
 			const diff = sqrtR - sqrtKPmX96;
 			const diffSqX192 = diff * diff;
 			return divTrunc(m * diffSqX192, rX192 - Q192$3);
@@ -14854,7 +14870,7 @@ function getLegGamma(leg, currentTick, positionSize, poolTickSpacing, assetIndex
 	const sqrtKPR = tickToSqrtPriceX96(qStrikeTick + qCurrentTick + halfWidthTick);
 	const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 	const rX192 = sqrtR * sqrtR;
-	const numerator = m * sqrtKPR * Q96$1;
+	const numerator = m * sqrtKPR * Q96$2;
 	const denominator = 2n * (rX192 - Q192$3);
 	return divTrunc(numerator, denominator);
 }
@@ -22321,6 +22337,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
 /**
@@ -22338,24 +22421,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$1,
-		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$1,
+			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
 	};
 }
@@ -23434,6 +23528,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);
@@ -23465,7 +23585,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];
@@ -23474,6 +23595,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]
 		});
@@ -23510,7 +23632,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];
@@ -23518,6 +23641,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]
 		});
@@ -23820,23 +23944,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$1,
-		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$1,
+			functionName: "getTickNetsV3",
+			args: [
+				poolAddress,
+				centerTick,
+				windowTicks
+			],
+			blockNumber: _meta.blockNumber
+		}).then(([windowTickData, windowNets]) => ({
+			ticks: windowTickData,
+			liquidityNets: windowNets
+		}))
 	});
 	return {
-		ticks: [...ticks],
-		liquidityNets: [...liquidityNets],
+		ticks,
+		liquidityNets,
 		_meta
 	};
 }
@@ -24009,22 +24144,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$1,
-		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$1,
+			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
 	};
 }
@@ -26751,7 +26896,7 @@ async function forceExerciseAndWait(params) {
 //#endregion
 //#region src/panoptic/v2/writes/protectedSettle.ts
 const POOL_ID_MASK = (1n << 64n) - 1n;
-const Q96 = 1n << 96n;
+const Q96$1 = 1n << 96n;
 const MAX_UINT128$1 = (1n << 128n) - 1n;
 const SETTLE_LIMITS = [
 	-887272n,
@@ -26771,7 +26916,7 @@ function minimumPokeSize(legs, tickSpacing) {
 		const sqrtLower = tickToSqrtPriceX96(lowerTick);
 		const sqrtUpper = tickToSqrtPriceX96(upperTick);
 		const delta = sqrtUpper - sqrtLower;
-		const liquidityFactor = leg.asset === 0n ? sqrtLower * sqrtUpper / Q96 : Q96;
+		const liquidityFactor = leg.asset === 0n ? sqrtLower * sqrtUpper / Q96$1 : Q96$1;
 		if (liquidityFactor === 0n) return void 0;
 		const requiredAmount = ceilDiv$1(delta, liquidityFactor);
 		const legSize = ceilDiv$1(requiredAmount, leg.optionRatio);
@@ -28547,6 +28692,62 @@ async function getLoanPositionsForToken(client, poolAddress, account, existingPo
 		};
 	});
 }
+async function buildRepayDispatch(params) {
+	const { client, account, poolAddress, chainId, token, amount, slippageBps, existingPositionIds, builderCode = 0n } = params;
+	if (amount <= 0n) throw new Error("Repayment amount must be positive");
+	const pool = await getPool({
+		client,
+		poolAddress,
+		chainId
+	});
+	const tokenIndex = resolveTokenIndex(token, pool.collateralTracker0.token, pool.collateralTracker1.token);
+	const loans = await getLoanPositionsForToken(client, poolAddress, account, existingPositionIds, tokenIndex);
+	if (loans.length === 0) throw new NoLoanPositionsError(token);
+	const totalDebt = loans.reduce((sum$1, l) => sum$1 + l.tokenAmount, 0n);
+	const loanIds = loans.map((l) => l.tokenId);
+	const remainder = totalDebt > amount ? totalDebt - amount : 0n;
+	const { low: tickLimitLow, high: tickLimitHigh } = tickLimits(pool.currentTick, slippageBps);
+	const ascendingLimits = [
+		tickLimitLow,
+		tickLimitHigh,
+		0n
+	];
+	const nonLoanIds = existingPositionIds.filter((id) => !loanIds.includes(id));
+	const opsPositionIds = [...loanIds];
+	const opsSizes = loanIds.map(() => 0n);
+	const opsLimits = loanIds.map(() => ascendingLimits);
+	let finalPositionIdList;
+	if (remainder > 0n) {
+		const { tokenId: newLoanId, adjustedSize } = buildUniqueLoan(pool.poolId, tokenIndex, tokenIndex, pool.currentTick, pool.tickSpacing, nonLoanIds, remainder);
+		opsPositionIds.push(newLoanId);
+		opsSizes.push(adjustedSize);
+		opsLimits.push(ascendingLimits);
+		finalPositionIdList = [...nonLoanIds, newLoanId];
+	} else finalPositionIdList = nonLoanIds;
+	return {
+		positionIdList: opsPositionIds,
+		finalPositionIdList,
+		positionSizes: opsSizes,
+		tickAndSpreadLimits: opsLimits,
+		usePremiaAsCollateral: false,
+		builderCode
+	};
+}
+/** Preview the same full or partial repayment dispatch used by smartRepay. */
+async function previewRepay(params) {
+	const dispatch$1 = await buildRepayDispatch(params);
+	const simulation = await simulateDispatch({
+		client: params.client,
+		account: params.account,
+		poolAddress: params.poolAddress,
+		existingPositionIdList: params.existingPositionIds,
+		...dispatch$1
+	});
+	return {
+		dispatch: dispatch$1,
+		simulation
+	};
+}
 /**
 * Smart repay: burns all loan positions for a token and optionally re-opens a smaller one.
 *
@@ -28560,37 +28761,9 @@ async function getLoanPositionsForToken(client, poolAddress, account, existingPo
 * @returns TxResult
 */
 async function smartRepay(params) {
-	const { client, walletClient, account, poolAddress, chainId, token, amount, slippageBps, existingPositionIds, builderCode = 0n, txOverrides } = params;
+	const { client, walletClient, account, poolAddress, txOverrides } = params;
 	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-		const pool = await getPool({
-			client,
-			poolAddress,
-			chainId
-		});
-		const tokenIndex = resolveTokenIndex(token, pool.collateralTracker0.token, pool.collateralTracker1.token);
-		const loans = await getLoanPositionsForToken(client, poolAddress, account, existingPositionIds, tokenIndex);
-		if (loans.length === 0) throw new NoLoanPositionsError(token);
-		const totalDebt = loans.reduce((sum$1, l) => sum$1 + l.tokenAmount, 0n);
-		const loanIds = loans.map((l) => l.tokenId);
-		const remainder = totalDebt > amount ? totalDebt - amount : 0n;
-		const { low: tickLimitLow, high: tickLimitHigh } = tickLimits(pool.currentTick, slippageBps);
-		const ascendingLimits = [
-			Number(tickLimitLow),
-			Number(tickLimitHigh),
-			0
-		];
-		const nonLoanIds = existingPositionIds.filter((id) => !loanIds.includes(id));
-		const opsPositionIds = [...loanIds];
-		const opsSizes = loanIds.map(() => 0n);
-		const opsLimits = loanIds.map(() => ascendingLimits);
-		let finalPositionIdList;
-		if (remainder > 0n) {
-			const { tokenId: newLoanId, adjustedSize } = buildUniqueLoan(pool.poolId, tokenIndex, tokenIndex, pool.currentTick, pool.tickSpacing, nonLoanIds, remainder);
-			opsPositionIds.push(newLoanId);
-			opsSizes.push(adjustedSize);
-			opsLimits.push(ascendingLimits);
-			finalPositionIdList = [...nonLoanIds, newLoanId];
-		} else finalPositionIdList = nonLoanIds;
+		const intent = await buildRepayDispatch(params);
 		try {
 			return await submitWrite({
 				client,
@@ -28600,12 +28773,12 @@ async function smartRepay(params) {
 				abi: panopticPoolV2Abi,
 				functionName: "dispatch",
 				args: [
-					opsPositionIds,
-					finalPositionIdList,
-					opsSizes,
-					opsLimits,
-					false,
-					builderCode
+					intent.positionIdList,
+					intent.finalPositionIdList,
+					intent.positionSizes,
+					intent.tickAndSpreadLimits.map((limits) => limits.map(Number)),
+					intent.usePremiaAsCollateral,
+					intent.builderCode
 				],
 				txOverrides
 			});
@@ -32031,15 +32204,29 @@ var _4663 = {
 	"panoptic": {
 		"pool": {
 			"version": "v4",
-			"panopticPool": "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
-			"collateralTracker0": "0x49eaAC32A7CD4B8fB2209a12859a95E0b20aB0e5",
-			"collateralTracker1": "0x670C44a0FC35dbC410498e47A6290a1C3196d191"
+			"panopticPool": "0x000000000c21b38c54AcA7c7145Df01ff09d69Bb",
+			"collateralTracker0": "0xDc508622CD7e3850c8240e88c10361Cf493465b6",
+			"collateralTracker1": "0x9212d804953bAf89C24ceFa6545aA293bA08a876"
+		},
+		"additionalPools": {
+			"spyUsdg30bpsV4": {
+				"version": "v4",
+				"panopticPool": "0x00000000989bcb6f24af4a1Ab2A6d6a31c98A58E",
+				"collateralTracker0": "0x49eaAC32A7CD4B8fB2209a12859a95E0b20aB0e5",
+				"collateralTracker1": "0x670C44a0FC35dbC410498e47A6290a1C3196d191"
+			},
+			"spyUsdg5bpsV4": {
+				"version": "v4",
+				"panopticPool": "0x000000000c21b38c54AcA7c7145Df01ff09d69Bb",
+				"collateralTracker0": "0xDc508622CD7e3850c8240e88c10361Cf493465b6",
+				"collateralTracker1": "0x9212d804953bAf89C24ceFa6545aA293bA08a876"
+			}
 		},
 		"v2": {
 			"semiFungiblePositionManagerV4": "0x00000000000005C3287f136Ef5AF56c68Ea6849f",
 			"semiFungiblePositionManagerV3": "0x00000000000005E4693aDc8Ec0f12D686f728198",
 			"builderFactory": "0x0000000000000a3D22E158417AA639D7F71b0FF7",
-			"riskEngine": "0x000000000000075e29cdaa9cb640a69e148ca7da",
+			"riskEngine": "0x0000000000000fE1E261f66ce2F44def4F5Ae0CB",
 			"panopticPoolImplementation": "0x000000000000135429F0DaCaB61639Bf6a63EbbC",
 			"collateralTrackerImplementation": "0x0000000000001d9c38CA405A2e04420865A08A33",
 			"panopticFactoryV4": "0x0000000000000c51d0f8cf4bd9adE7191372a625",
@@ -32055,13 +32242,29 @@ var _4663 = {
 		"0x0000000000000fe1e261f66ce2f44def4f5ae0cb",
 		"0x0000000000000f3fb82469581A74776178E76Ca4"
 	],
-	"markets": { "spyUsdg": {
-		"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
-		"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
-		"fee": 3e3,
-		"tickSpacing": 60,
-		"poolId": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd"
-	} },
+	"markets": {
+		"spyUsdg": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 500,
+			"tickSpacing": 5,
+			"poolId": "0xe5923c8a8be481ec89a2ca784a2bbfa4235de6d88f92260fd66b660c4babf907"
+		},
+		"spyUsdg30bps": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 3e3,
+			"tickSpacing": 60,
+			"poolId": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd"
+		},
+		"spyUsdg5bps": {
+			"currency0": "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C",
+			"currency1": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+			"fee": 500,
+			"tickSpacing": 5,
+			"poolId": "0xe5923c8a8be481ec89a2ca784a2bbfa4235de6d88f92260fd66b660c4babf907"
+		}
+	},
 	"subgraphs": {
 		"hypovault": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/hypovault-subgraph-robinhood/prod/gn",
 		"panoptic": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/panoptic-subgraph-robinhood/v2_prod/gn"
@@ -32229,6 +32432,10 @@ function getSpyUsdgMarket(deployment) {
 	if (market === void 0) throw new Error(`Missing SPY/USDG market for chainId ${deployment.chainId}`);
 	return market;
 }
+function requireDeploymentValue(value, label) {
+	if (value === void 0) throw new Error(`Missing deployment value: ${label}`);
+	return value;
+}
 const MAINNET_DEPLOYMENT = CHAIN_DEPLOYMENTS[MAINNET_CHAIN_ID];
 const MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.additionalPools?.ethUsdc5bpsV3;
 const MAINNET_PANOPTIC_V2_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.v2;
@@ -32257,9 +32464,13 @@ const ROBINHOOD_HYPOVAULT_ADDRESSES = ROBINHOOD_DEPLOYMENT.hypovault.vaults;
 const ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES = ROBINHOOD_DEPLOYMENT.hypovault.managers;
 const ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS = ROBINHOOD_DEPLOYMENT.hypovault.turnkeySigners;
 const ROBINHOOD_PANOPTIC_POOL_ADDRESSES = ROBINHOOD_DEPLOYMENT.panoptic.pool;
+const ROBINHOOD_SPY_USDG_30BPS_PANOPTIC_POOL_ADDRESSES = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.panoptic.additionalPools?.spyUsdg30bpsV4, "Robinhood SPY/USDG 30bps Panoptic pool");
+const ROBINHOOD_SPY_USDG_5BPS_PANOPTIC_POOL_ADDRESSES = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.panoptic.additionalPools?.spyUsdg5bpsV4, "Robinhood SPY/USDG 5bps Panoptic pool");
 const ROBINHOOD_PANOPTIC_V2_ADDRESSES = ROBINHOOD_DEPLOYMENT.panoptic.v2;
 const ROBINHOOD_RISK_ENGINES = ROBINHOOD_DEPLOYMENT.riskEngines;
 const ROBINHOOD_SPY_USDG_MARKET = getSpyUsdgMarket(ROBINHOOD_DEPLOYMENT);
+const ROBINHOOD_SPY_USDG_30BPS_MARKET = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.markets.spyUsdg30bps, "Robinhood SPY/USDG 30bps market");
+const ROBINHOOD_SPY_USDG_5BPS_MARKET = requireDeploymentValue(ROBINHOOD_DEPLOYMENT.markets.spyUsdg5bps, "Robinhood SPY/USDG 5bps market");
 
 //#endregion
 //#region ../deployments/src/vaultDisplayNames.js
@@ -32350,6 +32561,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. */
@@ -32542,6 +32878,221 @@ function preparePositionValueCurve(curve) {
 	};
 }
 
+//#endregion
+//#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$1 = mints[0];
+	if (mints.length !== 1 || !mint$1) throw new Error("Opening event is missing or ambiguous");
+	const balance = decodePositionBalance$1(mint$1.args.balanceData);
+	const close = burns.filter((burn) => burn.blockNumber > mintBlock || burn.logIndex > mint$1.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$1.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
 //#region src/panoptic/v2/react/cacheScopes.ts
 /**
@@ -33094,14 +33645,18 @@ function usePoolLiquidities(poolAddress, params, options) {
 			getClientCacheScopeKey(publicClient, clientScope),
 			params.queryAddress,
 			params.startTick,
-			params.nTicks
+			params.nTicks,
+			params.windowsPerSide ?? 0,
+			params.tickSpacing
 		],
 		queryFn: () => getPoolLiquidities({
 			client: publicClient,
 			poolAddress,
 			queryAddress: params.queryAddress,
 			startTick: params.startTick,
-			nTicks: params.nTicks
+			nTicks: params.nTicks,
+			windowsPerSide: params.windowsPerSide,
+			tickSpacing: params.tickSpacing
 		}),
 		enabled: options?.enabled,
 		refetchInterval: options?.refetchInterval,
@@ -34352,17 +34907,21 @@ function useUniswapV3PoolLiquidities(poolAddress, queryAddress, args, options) {
 			queryAddress,
 			args?.startTick,
 			args?.nTicks,
+			args?.windowsPerSide ?? 0,
+			args?.tickSpacing,
 			getClientCacheScopeKey(publicClient, clientScope)
 		],
 		queryFn: () => {
 			if (!poolAddress || !queryAddress || queryAddress === zeroAddress || !args) throw new PanopticValidationError("useUniswapV3PoolLiquidities: missing required args");
-			const { startTick, nTicks } = args;
+			const { startTick, nTicks, windowsPerSide, tickSpacing } = args;
 			return getUniswapV3PoolLiquidities({
 				client: publicClient,
 				poolAddress,
 				queryAddress,
 				startTick,
-				nTicks
+				nTicks,
+				windowsPerSide,
+				tickSpacing
 			});
 		},
 		enabled: (options?.enabled ?? true) && !!poolAddress && !!queryAddress && queryAddress !== zeroAddress && !!args,
@@ -34490,11 +35049,12 @@ function useUniswapV4PoolLiquidities(queryAddress, poolManager, poolId, args, op
 			args?.tickSpacing,
 			args?.startTick,
 			args?.nTicks,
+			args?.windowsPerSide ?? 0,
 			getClientCacheScopeKey(publicClient, clientScope)
 		],
 		queryFn: () => {
 			if (!queryAddress || !poolManager || !poolId || !args) throw new PanopticValidationError("useUniswapV4PoolLiquidities: missing required args");
-			const { tickSpacing, startTick, nTicks } = args;
+			const { tickSpacing, startTick, nTicks, windowsPerSide } = args;
 			return getUniswapV4PoolLiquidities({
 				client: publicClient,
 				queryAddress,
@@ -34502,7 +35062,8 @@ function useUniswapV4PoolLiquidities(queryAddress, poolManager, poolId, args, op
 				poolId,
 				tickSpacing,
 				startTick,
-				nTicks
+				nTicks,
+				windowsPerSide
 			});
 		},
 		enabled: (options?.enabled ?? true) && !!queryAddress && !!poolManager && !!poolId && !!args,
@@ -38015,5 +38576,5 @@ function useTxEventConfirmation({ txHash, poolAddress = zeroAddress, collateralT
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, calculateResyncBlock, calculateSpreadWad, calculateVarianceProfile, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralCurveTicks, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, emptyLiquidateParams, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralCurve, getCollateralCurveInputs, getCollateralData, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getHedgeLimits, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionDeltaMetrics, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositionValueCurve, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, realizedBeta, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useExecuteSettleSequence, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useForfeitablePremium, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePoolVersion, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSettlePremiumFrom as useSettlePremiumFromHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSettlePremiumBatch, useSimulateSettlePremiumFrom, useSimulateSettleSequence, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, calculatePositionVolatilityMetrics, calculateResyncBlock, calculateSpreadWad, calculateVarianceProfile, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralCurveTicks, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, emptyLiquidateParams, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feeGrowthInsideX128, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, fetchUniswapFeeData, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralCurve, getCollateralCurveInputs, getCollateralData, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getHedgeLimits, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionDeltaMetrics, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositionValueCurve, getPositionVolatilityHistory, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionGamma, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewRepay, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, realizedBeta, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useExecuteSettleSequence, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useForfeitablePremium, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePoolVersion, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSettlePremiumFrom as useSettlePremiumFromHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSettlePremiumBatch, useSimulateSettlePremiumFrom, useSimulateSettleSequence, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=react-public.js.map