@panoptic-eng/sdk 1.0.60 → 1.0.62

package/dist/panoptic/v2/index.js

@@ -1,4 +1,4 @@
-import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, erc20Abi, getAbiItem, getAddress, hexToString, keccak256, parseAbi, toFunctionSelector, toHex, trim, zeroAddress } from "viem";
+import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, erc20Abi, getAbiItem, getAddress, hexToString, keccak256, parseAbi, parseEventLogs, toFunctionSelector, toHex, trim, zeroAddress } from "viem";
 import { call, multicall } from "viem/actions";
 import Decimal from "decimal.js";
 
@@ -9397,6 +9397,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;
@@ -9425,6 +9429,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;
@@ -9438,7 +9443,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;
@@ -11109,12 +11114,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");
@@ -11269,7 +11274,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) {
@@ -11281,8 +11286,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),
@@ -11310,7 +11315,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),
@@ -11331,7 +11336,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 {
@@ -12737,6 +12742,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) {
@@ -14464,7 +14480,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.
@@ -14612,7 +14628,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);
@@ -14684,7 +14700,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);
 	}
@@ -14792,7 +14808,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);
@@ -14851,7 +14867,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);
 }
@@ -21640,6 +21656,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
 /**
@@ -21657,24 +21740,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
 	};
 }
@@ -22753,6 +22847,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);
@@ -22784,7 +22904,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];
@@ -22793,6 +22914,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]
 		});
@@ -22829,7 +22951,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];
@@ -22837,6 +22960,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]
 		});
@@ -23139,23 +23263,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
 	};
 }
@@ -23328,22 +23463,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
 	};
 }
@@ -26070,7 +26215,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,
@@ -26090,7 +26235,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);
@@ -27866,6 +28011,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.
 *
@@ -27879,37 +28080,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,
@@ -27919,12 +28092,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
 			});
@@ -31350,15 +31523,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",
@@ -31374,13 +31561,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"
@@ -31548,6 +31751,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;
@@ -31576,9 +31783,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
@@ -31669,6 +31880,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. */
@@ -31862,5 +32198,220 @@ function preparePositionValueCurve(curve) {
 }
 
 //#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, 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, 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, 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, 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, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+//#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
+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, 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, 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, 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, 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, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=index.js.map