@panoptic-eng/sdk 1.0.61 → 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";
 
@@ -11274,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) {
@@ -11286,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),
@@ -11315,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),
@@ -11336,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 {
@@ -14480,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.
@@ -14628,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);
@@ -14700,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);
 	}
@@ -14808,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);
@@ -14867,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);
 }
@@ -22914,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]
 		});
@@ -22959,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]
 		});
@@ -26213,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,
@@ -26233,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);
@@ -31521,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",
@@ -31545,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"
@@ -31719,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;
@@ -31747,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
@@ -31840,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. */
@@ -32033,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, 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, 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, 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, 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