@panoptic-eng/sdk 1.0.69 → 1.0.70

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

@@ -97,7 +97,7 @@ const UTILIZATION_DENOMINATOR = 10000n;
 
 //#endregion
 //#region src/panoptic/v2/formatters/tick.ts
-const Q192$7 = 1n << 192n;
+const Q192$8 = 1n << 192n;
 const RAW_PRICE_PRECISION = 40n;
 function pow10$2(exponent) {
 	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
@@ -187,7 +187,7 @@ const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
 function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
 	return {
 		numerator: sqrtPriceX96 * sqrtPriceX96,
-		denominator: Q192$7
+		denominator: Q192$8
 	};
 }
 function getRawPriceRatio(tick) {
@@ -10071,7 +10071,7 @@ function hasLoanOrCredit(tokenId) {
 const POOL_ID_MASK$4 = (1n << 64n) - 1n;
 const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
 const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
-const Q192$6 = 1n << 192n;
+const Q192$7 = 1n << 192n;
 /**
 * Floor integer square root for bigints (Newton's method). Mirrors the isqrt
 * used in reads/collateralEstimate.ts (buildNeutralLeg).
@@ -10118,7 +10118,7 @@ function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
 	const maxSafe = MAX_TICK - tickSpacing - 1n;
 	let signedStrike;
 	try {
-		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$6 / positionSize);
+		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$7 / positionSize);
 		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
 	} catch {
 		signedStrike = minSafe;
@@ -10990,7 +10990,7 @@ function formatGwei(wei, precision) {
 //#region src/panoptic/v2/tokenId/generateOverlapping.ts
 const MAX_UINT64$2 = (1n << 64n) - 1n;
 const MAX_UINT128$4 = (1n << 128n) - 1n;
-const Q192$5 = 1n << 192n;
+const Q192$6 = 1n << 192n;
 const MAX_TOKEN_DECIMALS = 255n;
 const MAX_DECIMAL_EXPONENT = 512n;
 function invalid$1(message) {
@@ -11036,7 +11036,7 @@ function quotePriceAtTick(tick, asset, assetDecimals, quoteDecimals) {
 	const orientedTick = asset === 0n ? tick : -tick;
 	const sqrtPriceX96 = tickToSqrtPriceX96(orientedTick);
 	let numerator = sqrtPriceX96 * sqrtPriceX96;
-	let denominator = Q192$5;
+	let denominator = Q192$6;
 	const decimalDifference = assetDecimals - quoteDecimals;
 	if (decimalDifference > 0n) numerator *= pow10$1(decimalDifference);
 	else if (decimalDifference < 0n) denominator *= pow10$1(-decimalDifference);
@@ -11056,7 +11056,7 @@ function isPriceGridStrike(strike, params, spacing, tickSpacing) {
 	}
 	return false;
 }
-function ceilDiv$5(value, divisor) {
+function ceilDiv$6(value, divisor) {
 	const quotient = value / divisor;
 	const remainder = value % divisor;
 	return remainder > 0n ? quotient + 1n : quotient;
@@ -11089,7 +11089,7 @@ function resolveLegs(legs) {
 function getCandidateStrikes(params, spacing, tickSpacing, halfWidth) {
 	const lower = MIN_TICK + halfWidth > params.currentTick - halfWidth + 1n ? MIN_TICK + halfWidth : params.currentTick - halfWidth + 1n;
 	const upper = MAX_TICK - halfWidth < params.currentTick + halfWidth - 1n ? MAX_TICK - halfWidth : params.currentTick + halfWidth - 1n;
-	const firstStrike = ceilDiv$5(lower, tickSpacing) * tickSpacing;
+	const firstStrike = ceilDiv$6(lower, tickSpacing) * tickSpacing;
 	const lastStrike = floorDiv$1(upper, tickSpacing) * tickSpacing;
 	const strikes = [];
 	for (let strike = firstStrike; strike <= lastStrike; strike += tickSpacing) if (isPriceGridStrike(strike, params, spacing, tickSpacing)) strikes.push(strike);
@@ -11311,10 +11311,41 @@ function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/tokenId/validate.ts
+/**
+* Validate a TokenId's structure using the rules of TokenId.validate.
+* This does not check pool registration, available liquidity, or account collateral.
+*/
+function getTokenIdValidationError(tokenId) {
+	if (tokenId < 0n || tokenId >= 1n << 256n) return "Token ID must fit in uint256.";
+	const legs = [];
+	for (let index = 0n; index < TOKEN_ID_BITS.MAX_LEGS; index++) {
+		const leg = decodeLeg(tokenId, index);
+		if (leg.optionRatio === 0n) {
+			const offset = TOKEN_ID_BITS.POOL_ID_SIZE + index * TOKEN_ID_BITS.LEG_SIZE;
+			if (tokenId >> offset !== 0n) return "Position contains empty or non-contiguous legs.";
+			break;
+		}
+		legs.push(leg);
+	}
+	if (legs.length === 0) return "Position must contain at least one leg.";
+	const chunks = new Set();
+	for (const leg of legs) {
+		const chunk = `${leg.strike}:${leg.width}:${leg.tokenType}`;
+		if (chunks.has(chunk)) return "Position contains duplicate legs sharing the same liquidity chunk.";
+		chunks.add(chunk);
+		if (leg.strike <= -887272n || leg.strike >= 887272n) return "Position strike must be inside the pool tick bounds.";
+		const partner = legs[Number(leg.riskPartner)];
+		if (!partner || partner.riskPartner !== leg.index) return "Position risk partners must reference existing legs and be mutual.";
+	}
+	return null;
+}
+
 //#endregion
 //#region src/uniswap/lpDeposit.ts
-const Q96$5 = 1n << 96n;
-const ceilDiv$4 = (n, d) => (n + d - 1n) / d;
+const Q96$6 = 1n << 96n;
+const ceilDiv$5 = (n, d) => (n + d - 1n) / d;
 /** Principal and separately identified funding headroom, in native token units. */
 function getLpDepositBreakdown(ranges, sqrtPriceX96) {
 	if (sqrtPriceX96 <= 0n) throw new Error("Invalid pool price");
@@ -11325,12 +11356,12 @@ 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$5 * (upper - price), upper * price);
-		amount1 += ceilDiv$4(liquidity * (price - lower), Q96$5);
+		amount0 += ceilDiv$5(liquidity * Q96$6 * (upper - price), upper * price);
+		amount1 += ceilDiv$5(liquidity * (price - lower), Q96$6);
 	}
 	const buffer = {
-		amount0: ceilDiv$4(amount0 * 5n, 100n),
-		amount1: ceilDiv$4(amount1 * 5n, 100n)
+		amount0: ceilDiv$5(amount0 * 5n, 100n),
+		amount1: ceilDiv$5(amount1 * 5n, 100n)
 	};
 	return {
 		principal: {
@@ -11354,7 +11385,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$5) / (upper - lower) : amount * Q96$5 / (upper - lower);
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$6) / (upper - lower) : amount * Q96$6 / (upper - lower);
 		return liquidity <= 0n ? [] : [{
 			tickLower: Number(tickLower),
 			tickUpper: Number(tickUpper),
@@ -11375,7 +11406,7 @@ function getLpPositionFunding(params) {
 	});
 	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
 	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
-	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$4(amount1 * Q96$5 * Q96$5, priceSquared) : amount1 + ceilDiv$4(amount0 * priceSquared, Q96$5 * Q96$5);
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$5(amount1 * Q96$6 * Q96$6, priceSquared) : amount1 + ceilDiv$5(amount0 * priceSquared, Q96$6 * Q96$6);
 	const principalInQuote = value(breakdown.principal);
 	const totalInQuote = value(breakdown.total);
 	return {
@@ -11397,7 +11428,7 @@ function getMaxLpPositionSize(params) {
 			...params,
 			positionSize: mid
 		});
-		const minimum = params.minimumRequirement ? ceilDiv$4(params.minimumRequirement.requiredInQuote * mid, params.minimumRequirement.referenceSize) : 0n;
+		const minimum = params.minimumRequirement ? ceilDiv$5(params.minimumRequirement.requiredInQuote * mid, params.minimumRequirement.referenceSize) : 0n;
 		if (funding.totalInQuote <= params.availableInQuote && minimum <= params.availableInQuote) low = mid;
 		else high = mid - 1n;
 	}
@@ -12857,7 +12888,7 @@ async function submitWriteRequest(params) {
 * Exported so callers can display the constant; prefer {@link applyMintBuffer}
 * over multiplying by it directly, which is how the rounding bug reappears.
 */
-const MINT_BUFFER = 10666667n;
+const MINT_BUFFER = 10750000n;
 /** `RiskEngine.DECIMALS` — the denominator {@link MINT_BUFFER} is taken over. */
 const MINT_BUFFER_DENOMINATOR = 10000000n;
 /** The compiled-in default, matching the deployed RiskEngine. */
@@ -14588,8 +14619,8 @@ async function assertLpPositionFunded(params) {
 
 //#endregion
 //#region src/uniswap/lpGreeks.ts
-const Q96$4 = 1n << 96n;
-const Q192$4 = 1n << 192n;
+const Q96$5 = 1n << 96n;
+const Q192$5 = 1n << 192n;
 /**
 * Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
 * at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
@@ -14599,8 +14630,8 @@ const Q192$4 = 1n << 192n;
 function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
 	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
 	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
-	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$4 / (sqrtC * sqrtB) : 0n;
-	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$4 : 0n;
+	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$5 / (sqrtC * sqrtB) : 0n;
+	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$5 : 0n;
 	return {
 		amount0,
 		amount1
@@ -14609,7 +14640,7 @@ function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liqu
 
 //#endregion
 //#region src/panoptic/v2/greeks/legLiquidity.ts
-const Q96$3 = 1n << 96n;
+const Q96$4 = 1n << 96n;
 function divCeil(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
@@ -14622,7 +14653,7 @@ function getLegLiquidityRange(leg, positionSize, tickSpacing) {
 	const sqrtLower = tickToSqrtPriceX96(lowerTick);
 	const sqrtUpper = tickToSqrtPriceX96(upperTick);
 	const amount = positionSize * leg.optionRatio;
-	const liquidity = leg.asset === 0n ? amount * (sqrtLower * sqrtUpper / Q96$3) / (sqrtUpper - sqrtLower) : amount * Q96$3 / (sqrtUpper - sqrtLower);
+	const liquidity = leg.asset === 0n ? amount * (sqrtLower * sqrtUpper / Q96$4) / (sqrtUpper - sqrtLower) : amount * Q96$4 / (sqrtUpper - sqrtLower);
 	return {
 		lowerTick,
 		upperTick,
@@ -14645,7 +14676,7 @@ function getLegTokenInventory(leg, currentTick, positionSize, tickSpacing, token
 		if (tokenIndex === 0n) {
 			const scaled = (liquidity << 96n) * span;
 			movedAmount = leg.isLong ? scaled / sqrtUpper / sqrtLower : divCeil(divCeil(scaled, sqrtUpper), sqrtLower);
-		} else movedAmount = leg.isLong ? liquidity * span / Q96$3 : divCeil(liquidity * span, Q96$3);
+		} else movedAmount = leg.isLong ? liquidity * span / Q96$4 : divCeil(liquidity * span, Q96$4);
 	}
 	const net = heldAmount - movedAmount;
 	return leg.isLong ? -net : net;
@@ -14654,8 +14685,8 @@ function getLegTokenInventory(leg, currentTick, positionSize, tickSpacing, token
 //#endregion
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
-const Q96$2 = 1n << 96n;
-const Q192$3 = 1n << 192n;
+const Q96$3 = 1n << 96n;
+const Q192$4 = 1n << 192n;
 /**
 * Convert tick to quote-denominated tick based on asset direction.
 *
@@ -14709,7 +14740,7 @@ function computeWidth0Notional(leg, m) {
 	const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
 	const sqrtKraw = tickToSqrtPriceX96(signedStrike);
 	const KrawX192 = sqrtKraw * sqrtKraw;
-	return divTrunc(m * KrawX192, Q192$3);
+	return divTrunc(m * KrawX192, Q192$4);
 }
 /**
 * Calculate value for a width=0 (loan/credit) leg.
@@ -14729,7 +14760,7 @@ function getLegValueWidth0(leg, m, qCurrentTick, qStrikeTick, qMintTick, isAsset
 		const sqrtPm = tickToSqrtPriceX96(qMintTick);
 		const PX192 = sqrtP * sqrtP;
 		const PmX192 = sqrtPm * sqrtPm;
-		return divTrunc(-notional * (PX192 - PmX192), Q192$3);
+		return divTrunc(-notional * (PX192 - PmX192), Q192$4);
 	} else return 0n;
 }
 /**
@@ -14758,7 +14789,7 @@ function getLegNetValueWidth0(leg, m, qCurrentTick, qMintTick, isAssetToken0, sw
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const PX192 = sqrtP * sqrtP;
 	const PmX192 = sqrtPm * sqrtPm;
-	if (borrowsAsset) return divTrunc(-notional * (PX192 - PmX192), Q192$3);
+	if (borrowsAsset) return divTrunc(-notional * (PX192 - PmX192), Q192$4);
 	return divTrunc(notional * PX192, PmX192) - notional;
 }
 /**
@@ -14780,7 +14811,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 			const sqrtPm$2 = tickToSqrtPriceX96(qMintTick);
 			const KX192 = sqrtK$1 * sqrtK$1;
 			const PmX192 = sqrtPm$2 * sqrtPm$2;
-			return divTrunc(m * (KX192 - PmX192), Q192$3);
+			return divTrunc(m * (KX192 - PmX192), Q192$4);
 		} else if (qMintTick > qStrikeTick + halfWidthTick) return 0n;
 		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
 		const sqrtPm$1 = tickToSqrtPriceX96(qMintTick);
@@ -14788,7 +14819,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 		const rX192$1 = sqrtR$1 * sqrtR$1;
 		const diff$1 = sqrtKR - sqrtPm$1;
 		const diffSqX192$1 = diff$1 * diff$1;
-		return divTrunc(m * diffSqX192$1, rX192$1 - Q192$3);
+		return divTrunc(m * diffSqX192$1, rX192$1 - Q192$4);
 	}
 	if (qMintTick < qStrikeTick - halfWidthTick) return 0n;
 	else if (qMintTick > qStrikeTick + halfWidthTick) {
@@ -14802,10 +14833,10 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 	const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const rX192 = sqrtR * sqrtR;
-	const sqrtKPmX96 = divTrunc(sqrtK * Q96$2, sqrtPm);
+	const sqrtKPmX96 = divTrunc(sqrtK * Q96$3, sqrtPm);
 	const diff = sqrtR - sqrtKPmX96;
 	const diffSqX192 = diff * diff;
-	return divTrunc(m * diffSqX192, rX192 - Q192$3);
+	return divTrunc(m * diffSqX192, rX192 - Q192$4);
 }
 /**
 * Check if leg is a call option (vs put).
@@ -14861,11 +14892,11 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 	if (qCurrentTick < qStrikeTick - halfWidthTick) {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const PX192 = sqrtP * sqrtP;
-		v = divTrunc(m * PX192, Q192$3);
+		v = divTrunc(m * PX192, Q192$4);
 	} else if (qCurrentTick > qStrikeTick + halfWidthTick) {
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 		const KX192 = sqrtK * sqrtK;
-		v = divTrunc(m * KX192, Q192$3);
+		v = divTrunc(m * KX192, Q192$4);
 	} else {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
@@ -14874,8 +14905,8 @@ 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$2 - PX192 - KX192);
-		const denominator = rX192 - Q192$3;
+		const numerator = m * (2n * sqrtPKR * Q96$3 - PX192 - KX192);
+		const denominator = rX192 - Q192$4;
 		v = divTrunc(numerator, denominator);
 	}
 	const debt = -m;
@@ -14884,19 +14915,19 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 	if (isPut) {
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 		const KX192 = sqrtK * sqrtK;
-		const debtK = divTrunc(debt * KX192, Q192$3);
+		const debtK = divTrunc(debt * KX192, Q192$4);
 		return debtK + v + itm;
 	} else {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const PX192 = sqrtP * sqrtP;
-		const debtP = divTrunc(debt * PX192, Q192$3);
+		const debtP = divTrunc(debt * PX192, Q192$4);
 		if (definedRisk) {
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const PmX192 = sqrtPm * sqrtPm;
-			const itmPm = divTrunc(itm * PmX192, Q192$3);
+			const itmPm = divTrunc(itm * PmX192, Q192$4);
 			return debtP + v + itmPm;
 		} else {
-			const itmP = divTrunc(itm * PX192, Q192$3);
+			const itmP = divTrunc(itm * PX192, Q192$4);
 			return debtP + v + itmP;
 		}
 	}
@@ -14932,7 +14963,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
 		const sqrtKraw = tickToSqrtPriceX96(signedStrike);
 		const KrawX192 = sqrtKraw * sqrtKraw;
-		const notional = divTrunc(m * KrawX192, Q192$3);
+		const notional = divTrunc(m * KrawX192, Q192$4);
 		return -notional;
 	}
 	if (halfWidthTick === 0n) {
@@ -14961,8 +14992,8 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
 		const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (sqrtKR - sqrtP) * Q192$3;
-		const denominator = sqrtP * (rX192 - Q192$3);
+		const numerator = m * (sqrtKR - sqrtP) * Q192$4;
+		const denominator = sqrtP * (rX192 - Q192$4);
 		vDelta = divTrunc(numerator, denominator);
 	}
 	const isPut = !isCall(leg.tokenType, isAssetToken0);
@@ -14982,10 +15013,10 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const rX192 = sqrtR * sqrtR;
-			const sqrtKPmX96 = sqrtK * Q96$2 / sqrtPm;
+			const sqrtKPmX96 = sqrtK * Q96$3 / sqrtPm;
 			const diff = sqrtR - sqrtKPmX96;
 			const diffSqX192 = diff * diff;
-			return divTrunc(m * diffSqX192, rX192 - Q192$3);
+			return divTrunc(m * diffSqX192, rX192 - Q192$4);
 		}
 	})();
 	return definedRisk ? debtDelta + vDelta : debtDelta + vDelta + itmDelta;
@@ -14994,7 +15025,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 function toVaultFrameAtTick(delta, fromAsset, vaultAssetIndex, currentTick, flipSignOnAssetInversion = false) {
 	if (fromAsset === vaultAssetIndex) return delta;
 	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
-	const converted = vaultAssetIndex === 0n ? delta * Q192$3 / (sqrtPriceX96 * sqrtPriceX96) : delta * sqrtPriceX96 * sqrtPriceX96 / Q192$3;
+	const converted = vaultAssetIndex === 0n ? delta * Q192$4 / (sqrtPriceX96 * sqrtPriceX96) : delta * sqrtPriceX96 * sqrtPriceX96 / Q192$4;
 	return flipSignOnAssetInversion ? -converted : converted;
 }
 /**
@@ -15043,8 +15074,8 @@ 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$2;
-	const denominator = 2n * (rX192 - Q192$3);
+	const numerator = m * sqrtKPR * Q96$3;
+	const denominator = 2n * (rX192 - Q192$4);
 	return divTrunc(numerator, denominator);
 }
 /**
@@ -17675,7 +17706,7 @@ function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
 	return (estimatedAmountIn * (BPS_DENOMINATOR$6 + slippageBps) + BPS_DENOMINATOR$6 - 1n) / BPS_DENOMINATOR$6;
 }
-function ceilDiv$3(numerator, denominator) {
+function ceilDiv$4(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
@@ -17780,7 +17811,7 @@ async function quoteTokenShortfallRecovery(params) {
 			const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
 			const estimatedAmountOut = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
+				creditInput = estimatedAmountOut > 0n ? ceilDiv$4(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
 				continue;
 			}
 			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
@@ -17835,7 +17866,7 @@ async function quoteTokenShortfallRecovery(params) {
 			};
 			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+			creditInput = ceilDiv$4(creditInput * requiredOutput, estimatedAmountOut) + 1n;
 		}
 		return {
 			available: false,
@@ -17890,7 +17921,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			creditOutSize = swapOutput > 0n ? ceilDiv$4(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 			continue;
 		}
 		const recoverySimulation = await simulateDispatch({
@@ -17945,7 +17976,7 @@ async function quoteTokenShortfallRecovery(params) {
 		if (decodedShortfall >= shortfallError.assetsRequested - shortfallError.assetBalance) return quotePrefixedExactInput(amountOut);
 		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
 		amountOut += additionalAmountOut;
-		creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+		creditOutSize = swapOutput > 0n ? ceilDiv$4(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return quotePrefixedExactInput(shortfallError.assetsRequested - shortfallError.assetBalance);
 }
@@ -21364,7 +21395,7 @@ async function getItmAmounts(params) {
 * high-decimal amount can't masquerade as real flow.
 */
 const FLOW_NEUTRAL_DUST_THRESHOLD = 1000n;
-const Q192$2 = 1n << 192n;
+const Q192$3 = 1n << 192n;
 const POOL_ID_MASK$2 = (1n << 64n) - 1n;
 /**
 * Floor integer square root for bigints (Newton's method). Exact for all
@@ -21400,7 +21431,7 @@ function buildNeutralLeg(tokenIndex, signedAmount, positionSize) {
 	const absAmount = signedAmount < 0n ? -signedAmount : signedAmount;
 	const legAsset = tokenIndex === 0n ? 1n : 0n;
 	const legIsLong = signedAmount < 0n;
-	const sqrtKrawX96 = isqrt(absAmount * Q192$2 / positionSize);
+	const sqrtKrawX96 = isqrt(absAmount * Q192$3 / positionSize);
 	let signedTick;
 	try {
 		signedTick = sqrtPriceX96ToTick(sqrtKrawX96);
@@ -21658,7 +21689,7 @@ async function createFlowNeutralTokenId(params) {
 	const sqrtPX96 = tickToSqrtPriceX96(tickBefore);
 	const valueAbs = (index, amount) => {
 		const abs$1 = amount < 0n ? -amount : amount;
-		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$2 : abs$1;
+		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$3 : abs$1;
 	};
 	const flowFor = (index) => index === 0n ? credit.creditAmount0 : credit.creditAmount1;
 	if (queryAddress !== void 0) {
@@ -22631,7 +22662,7 @@ async function getPoolLiquidities(params) {
 
 //#endregion
 //#region src/panoptic/v2/reads/accountGreeks.ts
-const Q192$1 = 1n << 192n;
+const Q192$2 = 1n << 192n;
 /**
 * Calculate account-level greeks using stored position data.
 *
@@ -22752,8 +22783,8 @@ async function getAccountGreeks(params) {
 		const assetBal = isAssetToken0 ? collateral.token0.assets : collateral.token1.assets;
 		const otherBal = isAssetToken0 ? collateral.token1.assets : collateral.token0.assets;
 		const sqrtPriceX96 = tickToSqrtPriceX96(BigInt(currentTick));
-		if (isAssetToken0) collateralValue = assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 + otherBal;
-		else collateralValue = assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
+		if (isAssetToken0) collateralValue = assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 + otherBal;
+		else collateralValue = assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
 		collateralDelta = assetBal;
 	}
 	return {
@@ -22793,7 +22824,7 @@ function calculateAccountGreeksPure(params) {
 		const totalDelta$1 = [];
 		for (let i = 0; i < n; i++) {
 			const sqrtPriceX96 = tickToSqrtPriceX96(atTicks[i]);
-			const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
+			const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 : assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96);
 			totalValue$1.push(assetValueInNumeraire + otherBal);
 			totalDelta$1.push(assetBal);
 		}
@@ -22843,7 +22874,7 @@ function calculateAccountGreeksPure(params) {
 	}
 	for (let i = 0; i < n; i++) {
 		const sqrtPriceX96 = tickToSqrtPriceX96(atTicks[i]);
-		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
+		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 : assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96);
 		totalValue[i] += assetValueInNumeraire + otherBal;
 		totalDelta[i] += assetBal;
 	}
@@ -25258,10 +25289,10 @@ async function processClosedPositions(client, queryAddress, positions) {
 //#endregion
 //#region src/panoptic/v2/reads/hedgeCapacity.ts
 const SCALE$1 = 10000000n;
-const FEE_SCALE = 10000n;
-const Q192 = 1n << 192n;
+const FEE_SCALE$1 = 10000n;
+const Q192$1 = 1n << 192n;
 const MASK128$1 = (1n << 128n) - 1n;
-const ceilDiv$2 = (value, divisor) => (value + divisor - 1n) / divisor;
+const ceilDiv$3 = (value, divisor) => (value + divisor - 1n) / divisor;
 function accountHedgeDelta({ positionIds, balances, collateralDelta, tick, tickSpacing, assetIndex }) {
 	return positionIds.reduce((sum$1, id, index) => {
 		const balance = balances[index];
@@ -25281,8 +25312,8 @@ function accountHedgeDelta({ positionIds, balances, collateralDelta, tick, tickS
 function buildCapacityHedge({ delta, assetIndex, tick, tickSpacing, poolId, notionalFee, swapFee }) {
 	const borrowToken = delta >= 0n ? assetIndex : assetIndex === 0n ? 1n : 0n;
 	const receiveToken = borrowToken === 0n ? 1n : 0n;
-	const amount = delta >= 0n ? delta : ceilDiv$2((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE, (1000000n - swapFee) * (FEE_SCALE - notionalFee));
-	const commission = ceilDiv$2(amount * notionalFee, FEE_SCALE);
+	const amount = delta >= 0n ? delta : ceilDiv$3((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE$1, (1000000n - swapFee) * (FEE_SCALE$1 - notionalFee));
+	const commission = ceilDiv$3(amount * notionalFee, FEE_SCALE$1);
 	const proceeds = toVaultFrameAtTick((amount - commission) * (1000000n - swapFee) / 1000000n, borrowToken, receiveToken, tick);
 	const tokenId = addLegToTokenId(poolId, {
 		index: 0n,
@@ -25314,7 +25345,7 @@ function hedgeMargin({ tokenData, balanceChanges, crossRatios, tick, buffer }) {
 	const surplus1 = balances[1] > required1 ? (balances[1] - required1) * crossRatios[1] / SCALE$1 : 0n;
 	const sqrt = tickToSqrtPriceX96(tick);
 	const price = sqrt * sqrt;
-	const pairs = sqrt < 1n << 96n ? [[balances[0] + surplus1 * Q192 / price, required0], [balances[1] * Q192 / price + surplus0, ceilDiv$2(required1 * Q192, price)]] : [[balances[0] * price / Q192 + surplus1, ceilDiv$2(required0 * price, Q192)], [balances[1] + surplus0 * price / Q192, required1]];
+	const pairs = sqrt < 1n << 96n ? [[balances[0] + surplus1 * Q192$1 / price, required0], [balances[1] * Q192$1 / price + surplus0, ceilDiv$3(required1 * Q192$1, price)]] : [[balances[0] * price / Q192$1 + surplus1, ceilDiv$3(required0 * price, Q192$1)], [balances[1] + surplus0 * price / Q192$1, required1]];
 	const headroom = pairs.map(([balance, required]) => balance - required);
 	return {
 		solvent: balances.every((balance) => balance >= 0n) && headroom.every((value) => value >= 0n),
@@ -25527,7 +25558,7 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 		if (hedge.amount > 0n && BigInt(legCount) >= maxLegs) return unavailable("leg-limit");
 		const totalAssets = hedge.borrowToken === 0n ? total0 : total1;
 		if (hedge.amount > 0n && (hedge.amount > MAX_SIZE || hedge.amount > borrowCapacity[Number(hedge.borrowToken)] || totalAssets === 0n)) return unavailable("capacity");
-		const projectedUtilization = currentUtilizations.map((util, i) => hedge.amount > 0n && BigInt(i) === hedge.borrowToken ? ceilDiv$2(util * totalAssets + hedge.amount * 10000n, totalAssets) : util);
+		const projectedUtilization = currentUtilizations.map((util, i) => hedge.amount > 0n && BigInt(i) === hedge.borrowToken ? ceilDiv$3(util * totalAssets + hedge.amount * 10000n, totalAssets) : util);
 		if (hedge.amount > 0n && projectedUtilization.some((util) => util > 10000n)) return unavailable("capacity");
 		const global = projectedUtilization.map((util, i) => util > globalUtilizations[i] ? util : globalUtilizations[i]);
 		const syntheticBalance = hedge.amount | projectedUtilization[0] << 128n | projectedUtilization[1] << 144n;
@@ -25619,6 +25650,90 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/positionMintFunding.ts
+const Q96$2 = 1n << 96n;
+const Q192 = 1n << 192n;
+const BPS = 10000n;
+const FEE_SCALE = 1000000n;
+const max = (a, b) => a > b ? a : b;
+const ceilDiv$2 = (n, d) => n > 0n ? (n + d - 1n) / d : n / d;
+/**
+* Estimate deposit-independent mint funding, including settlement and commission.
+* Swaps use spot conversion with fees and slippage allowance; execution still needs a live quote.
+* Received tokens cover post-mint margin but cannot fund the other tracker's upfront payment.
+* Each requiredValue is the starting balance when funding entirely in that token.
+*/
+function getPositionMintFunding(params) {
+	const { tokenId, positionSize, sqrtPriceX96, valuationSqrtPriceX96, swapAtMint, commissionRate, swapFee, slippageBps, required0, required1 } = params;
+	if (positionSize < 0n || sqrtPriceX96 <= 0n || valuationSqrtPriceX96 <= 0n || commissionRate < 0n || swapFee < 0n || swapFee >= FEE_SCALE || slippageBps < 0n || slippageBps >= BPS || required0 < 0n || required1 < 0n) throw new RangeError("Invalid mint funding inputs");
+	const { legs, tickSpacing } = decodeTokenId(tokenId);
+	const firstLeg = legs[0];
+	if (!firstLeg || tickSpacing <= 0n) throw new RangeError("Invalid position");
+	let paid0 = 0n;
+	let paid1 = 0n;
+	let itm0 = 0n;
+	let itm1 = 0n;
+	let notional0 = 0n;
+	let notional1 = 0n;
+	for (const leg of legs) {
+		const { sqrtLower, sqrtUpper, liquidity } = getLegLiquidityRange(leg.width === 0n ? {
+			...leg,
+			width: 2n
+		} : leg, positionSize, tickSpacing);
+		const round = !leg.isLong || leg.width === 0n ? ceilDiv$2 : (n, d) => n / d;
+		const moved0 = round((liquidity << 96n) * (sqrtUpper - sqrtLower), sqrtUpper * sqrtLower);
+		const moved1 = round(liquidity * (sqrtUpper - sqrtLower), Q96$2);
+		const sign = leg.isLong ? -1n : 1n;
+		let amm0 = 0n;
+		let amm1 = 0n;
+		if (leg.width > 0n) {
+			const price = max(sqrtLower, sqrtPriceX96 < sqrtUpper ? sqrtPriceX96 : sqrtUpper);
+			amm0 = sign * round((liquidity << 96n) * (sqrtUpper - price), sqrtUpper * price);
+			amm1 = sign * round(liquidity * (price - sqrtLower), Q96$2);
+			itm0 += leg.tokenType === 1n ? amm0 : 0n;
+			itm1 += leg.tokenType === 0n ? amm1 : 0n;
+		} else {
+			itm0 -= leg.tokenType === 0n ? sign * moved0 : 0n;
+			itm1 -= leg.tokenType === 1n ? sign * moved1 : 0n;
+		}
+		paid0 += amm0 - (leg.tokenType === 0n ? sign * moved0 : 0n);
+		paid1 += amm1 - (leg.tokenType === 1n ? sign * moved1 : 0n);
+		notional0 += leg.tokenType === 0n ? moved0 : 0n;
+		notional1 += leg.tokenType === 1n ? moved1 : 0n;
+	}
+	if (swapAtMint && (itm0 !== 0n || itm1 !== 0n)) {
+		const swapToken0 = itm0 !== 0n && (itm1 === 0n || firstLeg.asset === 0n);
+		const priceSquared$1 = sqrtPriceX96 * sqrtPriceX96;
+		const itm = swapToken0 ? itm0 : itm1;
+		const numerator = swapToken0 ? priceSquared$1 : Q192;
+		const denominator = swapToken0 ? Q192 : priceSquared$1;
+		const retained$1 = (FEE_SCALE - swapFee) * (BPS - slippageBps);
+		const scale$1 = FEE_SCALE * BPS;
+		const payment = itm > 0n ? ceilDiv$2(itm * numerator * scale$1, denominator * retained$1) : itm * numerator * retained$1 / (denominator * scale$1);
+		paid0 += swapToken0 ? -itm : payment;
+		paid1 += swapToken0 ? payment : -itm;
+	}
+	paid0 += ceilDiv$2(notional0 * commissionRate, BPS);
+	paid1 += ceilDiv$2(notional1 * commissionRate, BPS);
+	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
+	const inToken0 = (amount0, amount1) => amount0 + ceilDiv$2(amount1 * Q192, priceSquared);
+	const inToken1 = (amount0, amount1) => amount1 + ceilDiv$2(amount0 * priceSquared, Q192);
+	const retained = (FEE_SCALE - swapFee) * (BPS - slippageBps);
+	const scale = FEE_SCALE * BPS;
+	const spotSquared = sqrtPriceX96 * sqrtPriceX96;
+	const upfront0 = max(paid0, 0n) + ceilDiv$2(max(paid1, 0n) * Q192 * scale, spotSquared * retained);
+	const upfront1 = max(paid1, 0n) + ceilDiv$2(max(paid0, 0n) * spotSquared * scale, Q192 * retained);
+	const requiredValue0 = upfront0 + max(0n, inToken0(required0 - max(-paid0, 0n), required1 - max(-paid1, 0n)));
+	const requiredValue1 = upfront1 + max(0n, inToken1(required0 - max(-paid0, 0n), required1 - max(-paid1, 0n)));
+	return {
+		paid0,
+		paid1,
+		requiredValue0,
+		requiredValue1
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/sync/getSyncStatus.ts
 /**
@@ -32158,7 +32273,7 @@ const DEFAULT_INTERVAL_MS = 12000n;
 /**
 * Default maximum block range per poll.
 */
-const DEFAULT_MAX_BLOCK_RANGE = 1000n;
+const DEFAULT_MAX_BLOCK_RANGE$1 = 1000n;
 /**
 * Create an HTTP polling-based event fetcher.
 *
@@ -32195,7 +32310,7 @@ const DEFAULT_MAX_BLOCK_RANGE = 1000n;
 * ```
 */
 function createEventPoller(params) {
-	const { client, poolAddress, collateralTracker0, collateralTracker1, riskEngineAddress, sfpmAddress, poolManagerAddress, eventTypes, onLogs, onError, intervalMs = DEFAULT_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, fromBlock } = params;
+	const { client, poolAddress, collateralTracker0, collateralTracker1, riskEngineAddress, sfpmAddress, poolManagerAddress, eventTypes, onLogs, onError, intervalMs = DEFAULT_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE$1, fromBlock } = params;
 	let isRunning = false;
 	let lastPolledBlock = fromBlock ?? 0n;
 	let pollTimeout = null;
@@ -32383,6 +32498,1355 @@ function createEventPoller(params) {
 	};
 }
 
+//#endregion
+//#region src/abis/UniswapV3Pool.ts
+const UniswapV3PoolAbi = [
+	{
+		inputs: [],
+		stateMutability: "payable",
+		type: "constructor"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			}
+		],
+		name: "Burn",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount0",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount1",
+				type: "uint128"
+			}
+		],
+		name: "Collect",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount0",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount1",
+				type: "uint128"
+			}
+		],
+		name: "CollectProtocol",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "paid0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "paid1",
+				type: "uint256"
+			}
+		],
+		name: "Flash",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [{
+			indexed: false,
+			internalType: "uint16",
+			name: "observationCardinalityNextOld",
+			type: "uint16"
+		}, {
+			indexed: false,
+			internalType: "uint16",
+			name: "observationCardinalityNextNew",
+			type: "uint16"
+		}],
+		name: "IncreaseObservationCardinalityNext",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [{
+			indexed: false,
+			internalType: "uint160",
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}, {
+			indexed: false,
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		}],
+		name: "Initialize",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			}
+		],
+		name: "Mint",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol0Old",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol1Old",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol0New",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol1New",
+				type: "uint8"
+			}
+		],
+		name: "SetFeeProtocol",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "amount0",
+				type: "int256"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "amount1",
+				type: "int256"
+			},
+			{
+				indexed: false,
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "liquidity",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			}
+		],
+		name: "Swap",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			}
+		],
+		name: "burn",
+		outputs: [{
+			internalType: "uint256",
+			name: "amount0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "amount1",
+			type: "uint256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount0Requested",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "amount1Requested",
+				type: "uint128"
+			}
+		],
+		name: "collect",
+		outputs: [{
+			internalType: "uint128",
+			name: "amount0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "amount1",
+			type: "uint128"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "uint128",
+				name: "amount0Requested",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "amount1Requested",
+				type: "uint128"
+			}
+		],
+		name: "collectProtocol",
+		outputs: [{
+			internalType: "uint128",
+			name: "amount0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "amount1",
+			type: "uint128"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "factory",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "fee",
+		outputs: [{
+			internalType: "uint24",
+			name: "",
+			type: "uint24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal0X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal1X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "flash",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint16",
+			name: "observationCardinalityNext",
+			type: "uint16"
+		}],
+		name: "increaseObservationCardinalityNext",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint160",
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}],
+		name: "initialize",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "liquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "maxLiquidityPerTick",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "mint",
+		outputs: [{
+			internalType: "uint256",
+			name: "amount0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "amount1",
+			type: "uint256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		name: "observations",
+		outputs: [
+			{
+				internalType: "uint32",
+				name: "blockTimestamp",
+				type: "uint32"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulative",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityCumulativeX128",
+				type: "uint160"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint32[]",
+			name: "secondsAgos",
+			type: "uint32[]"
+		}],
+		name: "observe",
+		outputs: [{
+			internalType: "int56[]",
+			name: "tickCumulatives",
+			type: "int56[]"
+		}, {
+			internalType: "uint160[]",
+			name: "secondsPerLiquidityCumulativeX128s",
+			type: "uint160[]"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "",
+			type: "bytes32"
+		}],
+		name: "positions",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidity",
+				type: "uint128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthInside0LastX128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthInside1LastX128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint128",
+				name: "tokensOwed0",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "tokensOwed1",
+				type: "uint128"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "protocolFees",
+		outputs: [{
+			internalType: "uint128",
+			name: "token0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "token1",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint8",
+			name: "feeProtocol0",
+			type: "uint8"
+		}, {
+			internalType: "uint8",
+			name: "feeProtocol1",
+			type: "uint8"
+		}],
+		name: "setFeeProtocol",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "slot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint16",
+				name: "observationIndex",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinality",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinalityNext",
+				type: "uint16"
+			},
+			{
+				internalType: "uint8",
+				name: "feeProtocol",
+				type: "uint8"
+			},
+			{
+				internalType: "bool",
+				name: "unlocked",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "tickLower",
+			type: "int24"
+		}, {
+			internalType: "int24",
+			name: "tickUpper",
+			type: "int24"
+		}],
+		name: "snapshotCumulativesInside",
+		outputs: [
+			{
+				internalType: "int56",
+				name: "tickCumulativeInside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityInsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsInside",
+				type: "uint32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "bool",
+				name: "zeroForOne",
+				type: "bool"
+			},
+			{
+				internalType: "int256",
+				name: "amountSpecified",
+				type: "int256"
+			},
+			{
+				internalType: "uint160",
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "swap",
+		outputs: [{
+			internalType: "int256",
+			name: "amount0",
+			type: "int256"
+		}, {
+			internalType: "int256",
+			name: "amount1",
+			type: "int256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int16",
+			name: "",
+			type: "int16"
+		}],
+		name: "tickBitmap",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "tickSpacing",
+		outputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		name: "ticks",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulativeOutside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityOutsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsOutside",
+				type: "uint32"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token0",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token1",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/events/poolSwapStream.ts
+const DEFAULT_POLL_INTERVAL_MS$1 = 3e3;
+const FAILURE_WINDOW_MS = 3e4;
+const FAILURES_BEFORE_POLL = 3;
+const STREAM_RETRY_MIN_MS = 15e3;
+const STREAM_RETRY_MAX_MS = 3e5;
+const RESYNC_JITTER_MS = 2e3;
+const EVENT_SOURCE_CLOSED = 2;
+function parseRecord(data) {
+	const value = JSON.parse(data);
+	if (typeof value !== "object" || value === null) throw new Error("Malformed stream frame");
+	return value;
+}
+function bigintField(record, field) {
+	const value = record[field];
+	if (typeof value !== "string") throw new Error(`Stream frame is missing ${field}`);
+	return BigInt(value);
+}
+function numberField(record, field) {
+	const value = record[field];
+	if (typeof value !== "number") throw new Error(`Stream frame is missing ${field}`);
+	return value;
+}
+function parseStreamedKey(data) {
+	const record = parseRecord(data);
+	return {
+		blockNumber: bigintField(record, "blockNumber"),
+		logIndex: numberField(record, "logIndex")
+	};
+}
+function parseStreamedSwap(data) {
+	const record = parseRecord(data);
+	const transactionHash = record.transactionHash;
+	if (typeof transactionHash !== "string") throw new Error("Stream frame is missing transactionHash");
+	return {
+		...parseStreamedKey(data),
+		timestamp: bigintField(record, "timestamp"),
+		transactionHash,
+		tick: numberField(record, "tick"),
+		amount0: bigintField(record, "amount0"),
+		amount1: bigintField(record, "amount1"),
+		sqrtPriceX96: bigintField(record, "sqrtPriceX96"),
+		liquidity: bigintField(record, "liquidity")
+	};
+}
+function parseHead(data) {
+	return bigintField(parseRecord(data ?? ""), "head");
+}
+function defaultEventSource() {
+	const EventSourceCtor = globalThis.EventSource;
+	return EventSourceCtor && ((url) => new EventSourceCtor(url));
+}
+function toError$1(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* Stream a pool's swaps from the relay at `streamUrl`.
+*
+* Every `ready`/`resync` frame carries the relay's head; swaps from the cursor up
+* to that head are fetched over HTTP so nothing is lost across reconnects. A
+* stream that closes, or errors three times in 30 s, is replaced by HTTP polling
+* and retried with backoff; one that closes before ever opening is not retried.
+*/
+function streamPoolSwaps(params) {
+	const { client, pool, fromBlock, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS$1, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, streamUrl, onSwaps, onError, onRemoved, onTransport, eventSource = defaultEventSource() } = params;
+	let running = true;
+	let cursor = fromBlock === void 0 ? void 0 : fromBlock - 1n;
+	let transport = "off";
+	let failures = [];
+	let source;
+	let poller;
+	let retryTimer;
+	let retryDelayMs = STREAM_RETRY_MIN_MS;
+	let catchUpTimer;
+	let catchUpTarget;
+	let catchingUp = false;
+	let everOpened = false;
+	const setTransport = (next) => {
+		if (next === transport) return;
+		transport = next;
+		onTransport?.(next);
+	};
+	const advance = (block) => {
+		if (block !== void 0 && (cursor === void 0 || block > cursor)) cursor = block;
+	};
+	const report = (error) => {
+		if (running) onError?.(toError$1(error));
+	};
+	const catchUpPending = () => catchingUp || catchUpTarget !== void 0;
+	const runCatchUp = async () => {
+		catchingUp = true;
+		while (running && catchUpTarget !== void 0) {
+			const head = catchUpTarget;
+			catchUpTarget = void 0;
+			if (cursor === void 0) {
+				cursor = head;
+				continue;
+			}
+			try {
+				const { swaps } = await fetchPoolSwaps(client, pool, cursor + 1n, head, maxBlockRange);
+				if (!running) break;
+				const first = swaps[0];
+				const last = swaps[swaps.length - 1];
+				if (first && last) onSwaps(swaps, {
+					fromBlock: first.blockNumber,
+					toBlock: last.blockNumber
+				});
+				advance(head);
+			} catch (error) {
+				report(error);
+				if (catchUpTarget === void 0 || catchUpTarget < head) catchUpTarget = head;
+				catchingUp = false;
+				catchUpTimer = setTimeout(() => void runCatchUp(), pollIntervalMs);
+				return;
+			}
+		}
+		catchingUp = false;
+	};
+	const catchUp = (head, delayMs = 0) => {
+		if (catchUpTarget === void 0 || head > catchUpTarget) catchUpTarget = head;
+		if (catchingUp) return;
+		if (catchUpTimer !== void 0) clearTimeout(catchUpTimer);
+		catchUpTimer = setTimeout(() => {
+			catchUpTimer = void 0;
+			runCatchUp();
+		}, delayMs);
+	};
+	const startPolling = () => {
+		if (poller) return;
+		poller = watchPoolSwaps({
+			client,
+			pool,
+			fromBlock: cursor === void 0 ? void 0 : cursor + 1n,
+			pollIntervalMs,
+			maxBlockRange,
+			onSwaps,
+			onError
+		});
+		setTransport("poll");
+	};
+	const stopPolling = () => {
+		if (!poller) return;
+		advance(poller.lastScannedBlock());
+		poller.stop();
+		poller = void 0;
+	};
+	const closeStream = () => {
+		source?.close();
+		source = void 0;
+	};
+	const scheduleStreamRetry = () => {
+		retryTimer = setTimeout(() => {
+			retryTimer = void 0;
+			if (running) openStream();
+		}, retryDelayMs);
+		retryDelayMs = Math.min(retryDelayMs * 2, STREAM_RETRY_MAX_MS);
+	};
+	const openStream = () => {
+		if (!eventSource) {
+			startPolling();
+			return;
+		}
+		const es = eventSource(streamUrl);
+		source = es;
+		failures = [];
+		let opened = false;
+		const listen = (type, handle) => es.addEventListener(type, (event) => {
+			if (!running || source !== es) return;
+			try {
+				handle(event.data);
+			} catch (error) {
+				report(error);
+			}
+		});
+		listen("open", () => {
+			opened = true;
+			everOpened = true;
+			failures = [];
+			retryDelayMs = STREAM_RETRY_MIN_MS;
+		});
+		listen("ready", (data) => {
+			const head = parseHead(data);
+			stopPolling();
+			setTransport("stream");
+			catchUp(head);
+		});
+		listen("resync", (data) => {
+			catchUp(parseHead(data), Math.random() * RESYNC_JITTER_MS);
+		});
+		listen("swap", (data) => {
+			const swap = parseStreamedSwap(data ?? "");
+			onSwaps([swap], {
+				fromBlock: swap.blockNumber,
+				toBlock: swap.blockNumber
+			});
+			if (!catchUpPending()) advance(swap.blockNumber);
+		});
+		listen("removed", (data) => {
+			onRemoved?.(parseStreamedKey(data ?? ""));
+		});
+		listen("error", () => {
+			const now = Date.now();
+			failures = failures.filter((at) => now - at < FAILURE_WINDOW_MS);
+			failures.push(now);
+			const closed = es.readyState === EVENT_SOURCE_CLOSED;
+			if (!closed && failures.length < FAILURES_BEFORE_POLL) return;
+			closeStream();
+			startPolling();
+			if (closed && !opened && !everOpened) return;
+			scheduleStreamRetry();
+		});
+	};
+	openStream();
+	return {
+		stop() {
+			running = false;
+			closeStream();
+			stopPolling();
+			if (retryTimer !== void 0) clearTimeout(retryTimer);
+			if (catchUpTimer !== void 0) clearTimeout(catchUpTimer);
+			setTransport("off");
+		},
+		lastScannedBlock: () => cursor,
+		transport: () => transport
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/events/poolSwaps.ts
+const DEFAULT_POLL_INTERVAL_MS = 3e3;
+const DEFAULT_MAX_BLOCK_RANGE = 2000n;
+const SHARED_BUFFER_LIMIT = 4096;
+/**
+* Parse a decoded v3 `UniswapV3Pool.Swap` or v4 `PoolManager.Swap` log.
+*/
+function parseSwapLog(log, timestamp) {
+	if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) throw new Error("Cannot parse a pending Swap log");
+	const args = log.args;
+	return {
+		blockNumber: log.blockNumber,
+		logIndex: log.logIndex,
+		timestamp,
+		transactionHash: log.transactionHash,
+		tick: Number(args.tick),
+		amount0: args.amount0,
+		amount1: args.amount1,
+		sqrtPriceX96: args.sqrtPriceX96,
+		liquidity: args.liquidity
+	};
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+async function fetchSwapLogs(client, pool, fromBlock, toBlock) {
+	if (pool.version === "v3") return client.getContractEvents({
+		address: pool.poolAddress,
+		abi: UniswapV3PoolAbi,
+		eventName: "Swap",
+		fromBlock,
+		toBlock
+	});
+	return client.getContractEvents({
+		address: pool.poolManager,
+		abi: poolManagerAbi,
+		eventName: "Swap",
+		args: { id: pool.poolId },
+		fromBlock,
+		toBlock
+	});
+}
+async function fetchSwaps(client, pool, fromBlock, toBlock) {
+	const logs = await fetchSwapLogs(client, pool, fromBlock, toBlock);
+	if (logs.length === 0) return [];
+	const blockNumbers = [...new Set(logs.flatMap((log) => log.blockNumber === null ? [] : [log.blockNumber]))];
+	const blocks = await Promise.all(blockNumbers.map((blockNumber) => client.getBlock({ blockNumber })));
+	const timestamps = new Map(blocks.map((block, i) => [blockNumbers[i], block.timestamp]));
+	return logs.map((log) => parseSwapLog(log, timestamps.get(log.blockNumber ?? -1n) ?? 0n)).sort((a, b) => a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1);
+}
+/**
+* Fetch a pool's swaps in `[fromBlock, toBlock]` (default: the current head), in
+* chain order. Returns no swaps when `fromBlock > toBlock`.
+*/
+async function fetchPoolSwaps(client, pool, fromBlock, toBlock, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE) {
+	const end = toBlock ?? await client.getBlockNumber();
+	const swaps = [];
+	for (let from = fromBlock; from <= end; from += maxBlockRange) {
+		const to = from + maxBlockRange - 1n < end ? from + maxBlockRange - 1n : end;
+		swaps.push(...await fetchSwaps(client, pool, from, to));
+	}
+	return {
+		swaps,
+		toBlock: end
+	};
+}
+/**
+* Poll a single pool's `Swap` logs with `eth_getLogs`, timestamped by block.
+*
+* Works over plain HTTP (no filters or websockets). A chunk that fails is retried on
+* the next tick; errors never stop the loop.
+*/
+function watchPoolSwaps(params) {
+	const { client, pool, fromBlock, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, onSwaps, onError } = params;
+	let running = true;
+	let lastScanned;
+	let timer;
+	const poll = async () => {
+		try {
+			const head = await client.getBlockNumber();
+			let from = lastScanned !== void 0 ? lastScanned + 1n : fromBlock ?? head;
+			while (running && from <= head) {
+				const to = from + maxBlockRange - 1n < head ? from + maxBlockRange - 1n : head;
+				const swaps = await fetchSwaps(client, pool, from, to);
+				if (!running) return;
+				if (swaps.length > 0) onSwaps(swaps, {
+					fromBlock: from,
+					toBlock: to
+				});
+				lastScanned = to;
+				from = to + 1n;
+			}
+		} catch (error) {
+			if (running) onError?.(toError(error));
+		}
+		if (running) timer = setTimeout(() => void poll(), pollIntervalMs);
+	};
+	poll();
+	return {
+		stop() {
+			running = false;
+			if (timer !== void 0) clearTimeout(timer);
+		},
+		lastScannedBlock: () => lastScanned
+	};
+}
+const sharedWatchers = new Map();
+function swapKey(key) {
+	return `${key.blockNumber}:${key.logIndex}`;
+}
+/**
+* Ref-counted pool swap feed: subscribers with the same `key` share one watcher
+* (relay stream when `streamUrl` is set, else HTTP polling), duplicates are
+* dropped, late subscribers first receive the swaps already seen, and the watcher
+* stops when the last subscriber unsubscribes.
+*/
+function subscribePoolSwaps(params) {
+	const { key, streamUrl, onSwaps, onError, onRemoved, onTransport,...watchParams } = params;
+	const listener = {
+		onSwaps,
+		onError,
+		onRemoved,
+		onTransport
+	};
+	const existing = sharedWatchers.get(key);
+	if (existing) {
+		existing.listeners.add(listener);
+		const buffered = [...existing.buffer.values()];
+		const first = buffered[0];
+		const last = buffered[buffered.length - 1];
+		if (first && last) onSwaps(buffered, {
+			fromBlock: first.blockNumber,
+			toBlock: last.blockNumber
+		});
+		onTransport?.(existing.transport);
+	} else {
+		const listeners = new Set([listener]);
+		const buffer = new Map();
+		const entry = {
+			watcher: {
+				stop: () => void 0,
+				lastScannedBlock: () => void 0
+			},
+			listeners,
+			buffer,
+			transport: "off"
+		};
+		const setTransport = (transport) => {
+			entry.transport = transport;
+			for (const l of listeners) l.onTransport?.(transport);
+		};
+		const callbacks = {
+			onSwaps: (swaps, range) => {
+				const fresh = swaps.filter((swap) => !buffer.has(swapKey(swap)));
+				if (fresh.length === 0) return;
+				for (const swap of fresh) buffer.set(swapKey(swap), swap);
+				for (const k of buffer.keys()) {
+					if (buffer.size <= SHARED_BUFFER_LIMIT) break;
+					buffer.delete(k);
+				}
+				for (const l of listeners) l.onSwaps(fresh, range);
+			},
+			onError: (error) => {
+				for (const l of listeners) l.onError?.(error);
+			}
+		};
+		sharedWatchers.set(key, entry);
+		if (streamUrl !== void 0) entry.watcher = streamPoolSwaps({
+			...watchParams,
+			...callbacks,
+			streamUrl,
+			onRemoved: (removed) => {
+				buffer.delete(swapKey(removed));
+				for (const l of listeners) l.onRemoved?.(removed);
+			},
+			onTransport: setTransport
+		});
+		else {
+			entry.watcher = watchPoolSwaps({
+				...watchParams,
+				...callbacks
+			});
+			setTransport("poll");
+		}
+	}
+	return () => {
+		const entry = sharedWatchers.get(key);
+		if (!entry) return;
+		entry.listeners.delete(listener);
+		if (entry.listeners.size === 0) {
+			entry.watcher.stop();
+			sharedWatchers.delete(key);
+		}
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/strike/ladder.ts
 /** Target number of rungs across a leg's full range (lower tick → upper tick). */
@@ -33860,7 +35324,7 @@ function calculatePositionVolatilityMetrics({ observations, netPremium, baseFees
 	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 peak = gammas.reduce((max$1, gamma) => Precision.max(max$1, 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()));
@@ -38984,7 +40448,53 @@ function useTxEventConfirmation({ txHash, poolAddress = zeroAddress, collateralT
 		isSuccess: data !== void 0
 	};
 }
+/**
+* Follow a pool's Uniswap `Swap` logs while `enabled`: streamed from `streamUrl`
+* when given, else polled over HTTP. Mounts with the same chain, pool, `fromBlock`
+* and `streamUrl` share one watcher. Takes the client explicitly so it works
+* outside `PanopticProvider`.
+*/
+function usePoolSwaps(params) {
+	const { client, chainId, pool, fromBlock, streamUrl, enabled } = params;
+	const [transport, setTransport] = useState("off");
+	const onSwapsRef = useRef(params.onSwaps);
+	onSwapsRef.current = params.onSwaps;
+	const onRemovedRef = useRef(params.onRemoved);
+	onRemovedRef.current = params.onRemoved;
+	const onErrorRef = useRef(params.onError);
+	onErrorRef.current = params.onError;
+	const poolKey = pool ? pool.version === "v3" ? pool.poolAddress.toLowerCase() : `${pool.poolManager.toLowerCase()}:${pool.poolId.toLowerCase()}` : void 0;
+	const poolRef = useRef(pool);
+	poolRef.current = pool;
+	useEffect(() => {
+		const currentPool = poolRef.current;
+		if (!enabled || !client || !currentPool || poolKey === void 0 || fromBlock === void 0) return;
+		const unsubscribe = subscribePoolSwaps({
+			key: `${chainId}:${poolKey}:${fromBlock}:${streamUrl ?? "poll"}`,
+			client,
+			pool: currentPool,
+			fromBlock,
+			streamUrl,
+			onSwaps: (swaps) => onSwapsRef.current(swaps),
+			onRemoved: (key) => onRemovedRef.current?.(key),
+			onError: (error) => onErrorRef.current?.(error),
+			onTransport: setTransport
+		});
+		return () => {
+			unsubscribe();
+			setTransport("off");
+		};
+	}, [
+		client,
+		chainId,
+		poolKey,
+		fromBlock,
+		streamUrl,
+		enabled
+	]);
+	return { transport };
+}
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, 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, estimateCloseZapSwap, 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, getClosePositionTransferEstimate, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralCurve, getCollateralCurveInputs, getCollateralData, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getHedgeLimits, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionDeltaMetrics, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositionValueCurve, getPositionVolatilityHistory, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, prepareLiquidityGamma, preparePositionGamma, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewRepay, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, 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, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useExecuteSettleSequence, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useForfeitablePremium, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePoolVersion, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSettlePremiumFrom as useSettlePremiumFromHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSettlePremiumBatch, useSimulateSettlePremiumFrom, useSimulateSettleSequence, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, calculatePositionVolatilityMetrics, calculateResyncBlock, calculateSpreadWad, calculateVarianceProfile, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralCurveTicks, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, emptyLiquidateParams, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feeGrowthInsideX128, feesFromFeeGrowthDelta, fetchPoolId, fetchPoolSwaps, 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, getClosePositionTransferEstimate, 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, getPositionMintFunding, getPositionValueCurve, getPositionVolatilityHistory, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenIdValidationError, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseStreamedKey, parseStreamedSwap, parseSwapLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, prepareLiquidityGamma, preparePositionGamma, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewRepay, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, 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, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, streamPoolSwaps, subscribePoolSwaps, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useExecuteSettleSequence, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useForfeitablePremium, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePoolSwaps, usePoolVersion, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSettlePremiumFrom as useSettlePremiumFromHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSettlePremiumBatch, useSimulateSettlePremiumFrom, useSimulateSettleSequence, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, watchPoolSwaps, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=react-public.js.map