@panoptic-eng/sdk 1.0.40 → 1.0.42

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

@@ -10027,1763 +10027,1922 @@ function hasLoanOrCredit(tokenId) {
 }
 
 //#endregion
-//#region src/panoptic/v2/sfpmSwap/calldata.ts
-/**
-* Encode the `multicall([mint, burn])` for a swap plan.
-*
-* The order is always `[mint, burn]` — the ERC1155 must be minted before it is
-* burned. Which call carries the inverted (swap) limits is decided in the plan.
-*/
-function buildSfpmSwapCalldata(plan) {
-	const mintData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "mintTokenizedPosition",
-		args: [
-			plan.poolKey,
-			plan.tokenId,
-			plan.positionSize,
-			plan.mintTickLimits[0],
-			plan.mintTickLimits[1]
-		]
-	});
-	const burnData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "burnTokenizedPosition",
-		args: [
-			plan.poolKey,
-			plan.tokenId,
-			plan.positionSize,
-			plan.burnTickLimits[0],
-			plan.burnTickLimits[1]
-		]
-	});
-	const multicallData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "multicall",
-		args: [[mintData, burnData]]
-	});
+//#region src/panoptic/v2/formatters/tick.ts
+const Q192$4 = 1n << 192n;
+const RAW_PRICE_PRECISION = 40n;
+function pow10(exponent) {
+	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
+	return 10n ** exponent;
+}
+function absBigint(value) {
+	return value < 0n ? -value : value;
+}
+function trimTrailingZeros(value) {
+	const dotIndex = value.indexOf(".");
+	if (dotIndex === -1) return value;
+	let end = value.length;
+	while (end > dotIndex && value[end - 1] === "0") end -= 1;
+	if (end === dotIndex + 1) end = dotIndex;
+	return value.slice(0, end);
+}
+function formatRatio$3(numerator, denominator, precision) {
+	if (precision < 0n) throw new RangeError("Precision must be non-negative");
+	const sign = numerator < 0n ? "-" : "";
+	const absNumerator = numerator < 0n ? -numerator : numerator;
+	const scale = pow10(precision);
+	const scaled = (absNumerator * scale + denominator / 2n) / denominator;
+	const integerPart = scaled / scale;
+	const fractionalPart = scaled % scale;
+	if (precision === 0n) return `${sign}${integerPart}`;
+	return `${sign}${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
+}
+function parseDecimalToFraction(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) throw new Error("Price must be a number");
+	const isNegative = trimmed.startsWith("-");
+	const unsigned = isNegative || trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
+	const [basePart, exponentPart] = unsigned.toLowerCase().split("e");
+	const [integerStr, fractionalStr = ""] = basePart.split(".");
+	if (integerStr === "" && fractionalStr === "") throw new Error("Price must be a number");
+	const integerDigits = integerStr === "" ? "0" : integerStr;
+	const digits = `${integerDigits}${fractionalStr}`;
+	let numerator = BigInt(digits === "" ? "0" : digits);
+	let denominator = pow10(BigInt(fractionalStr.length));
+	if (exponentPart !== void 0 && exponentPart !== "") {
+		const exponent = BigInt(exponentPart);
+		if (exponent > 0n) numerator *= pow10(exponent);
+		else if (exponent < 0n) denominator *= pow10(-exponent);
+	}
+	if (isNegative) numerator = -numerator;
 	return {
-		multicallData,
-		mintData,
-		burnData
+		numerator,
+		denominator
 	};
 }
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/init.ts
-/**
-* Resolve the `uint64` SFPM poolId for a Uniswap v3 pool, initializing it if needed.
-*
-* `initializeAMMPool` is permissionless and idempotent and **returns the poolId**
-* whether or not the pool was already registered, so a `simulateContract` call is
-* enough to learn the id without sending a transaction. Always resolve the id this
-* way rather than encoding it offline — the SFPM can collision-increment ids.
-*/
-async function fetchSfpmV3PoolId(params) {
-	const { client, sfpmAddress, token0, token1, fee } = params;
-	const vegoid$1 = params.vegoid ?? Number(DEFAULT_VEGOID);
-	const { result } = await client.simulateContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "initializeAMMPool",
-		args: [
-			token0,
-			token1,
-			fee,
-			vegoid$1
-		]
-	});
-	return BigInt(result);
+function compareRatios(leftNumerator, leftDenominator, rightNumerator, rightDenominator) {
+	const left = leftNumerator * rightDenominator;
+	const right = rightNumerator * leftDenominator;
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
 }
-/**
-* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
-* only if it is not already registered. Returns the resolved poolId.
-*
-* When `expectedPool` is given, the resolved id is checked to map back to it via
-* `getUniswapV3PoolFromId` — guards against a wrong token/fee triple.
-*/
-async function ensureSfpmV3PoolInitialized(params) {
-	const { client, wallet, sfpmAddress, token0, token1, fee, expectedPool } = params;
-	const vegoid$1 = params.vegoid ?? Number(DEFAULT_VEGOID);
-	const poolId = await fetchSfpmV3PoolId({
-		client,
-		sfpmAddress,
-		token0,
-		token1,
-		fee,
-		vegoid: vegoid$1
-	});
-	const registered = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
-	});
-	let initialized = false;
-	let resolved = registered;
-	if (getAddress(registered) === zeroAddress) {
-		const account = wallet.account;
-		if (account === void 0) throw new PanopticError("wallet client has no account");
-		const hash = await wallet.writeContract({
-			account,
-			chain: wallet.chain ?? null,
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "initializeAMMPool",
-			args: [
-				token0,
-				token1,
-				fee,
-				vegoid$1
-			]
-		});
-		await client.waitForTransactionReceipt({ hash });
-		initialized = true;
-		resolved = await client.readContract({
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "getUniswapV3PoolFromId",
-			args: [poolId]
-		});
-	}
-	if (expectedPool !== void 0 && getAddress(resolved) !== getAddress(expectedPool)) throw new WrongUniswapPoolError(new PanopticError(`SFPM poolId ${poolId} resolves to ${resolved}, expected ${expectedPool}`));
+function tickToSqrtPriceX96(tick) {
+	if (tick < MIN_TICK || tick > MAX_TICK) throw new RangeError("Tick out of bounds");
+	const absTick = tick < 0n ? -tick : tick;
+	let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+	if ((absTick & 0x2n) !== 0n) ratio = ratio * 0xfff97272373d413259a46990580e213an >> 128n;
+	if ((absTick & 0x4n) !== 0n) ratio = ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn >> 128n;
+	if ((absTick & 0x8n) !== 0n) ratio = ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n >> 128n;
+	if ((absTick & 0x10n) !== 0n) ratio = ratio * 0xffcb9843d60f6159c9db58835c926644n >> 128n;
+	if ((absTick & 0x20n) !== 0n) ratio = ratio * 0xff973b41fa98c081472e6896dfb254c0n >> 128n;
+	if ((absTick & 0x40n) !== 0n) ratio = ratio * 0xff2ea16466c96a3843ec78b326b52861n >> 128n;
+	if ((absTick & 0x80n) !== 0n) ratio = ratio * 0xfe5dee046a99a2a811c461f1969c3053n >> 128n;
+	if ((absTick & 0x100n) !== 0n) ratio = ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n >> 128n;
+	if ((absTick & 0x200n) !== 0n) ratio = ratio * 0xf987a7253ac413176f2b074cf7815e54n >> 128n;
+	if ((absTick & 0x400n) !== 0n) ratio = ratio * 0xf3392b0822b70005940c7a398e4b70f3n >> 128n;
+	if ((absTick & 0x800n) !== 0n) ratio = ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n >> 128n;
+	if ((absTick & 0x1000n) !== 0n) ratio = ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n >> 128n;
+	if ((absTick & 0x2000n) !== 0n) ratio = ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n >> 128n;
+	if ((absTick & 0x4000n) !== 0n) ratio = ratio * 0x70d869a156d2a1b890bb3df62baf32f7n >> 128n;
+	if ((absTick & 0x8000n) !== 0n) ratio = ratio * 0x31be135f97d08fd981231505542fcfa6n >> 128n;
+	if ((absTick & 0x10000n) !== 0n) ratio = ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n >> 128n;
+	if ((absTick & 0x20000n) !== 0n) ratio = ratio * 0x5d6af8dedb81196699c329225ee604n >> 128n;
+	if ((absTick & 0x40000n) !== 0n) ratio = ratio * 0x2216e584f5fa1ea926041bedfe98n >> 128n;
+	if ((absTick & 0x80000n) !== 0n) ratio = ratio * 0x48a170391f7dc42444e8fa2n >> 128n;
+	if (tick > 0n) ratio = ((1n << 256n) - 1n) / ratio;
+	const remainderMask = (1n << 32n) - 1n;
+	const sqrtPriceX96 = (ratio >> 32n) + ((ratio & remainderMask) === 0n ? 0n : 1n);
+	return sqrtPriceX96;
+}
+const MIN_SQRT_PRICE_X96 = tickToSqrtPriceX96(MIN_TICK);
+const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
+function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
 	return {
-		poolId,
-		initialized
+		numerator: sqrtPriceX96 * sqrtPriceX96,
+		denominator: Q192$4
 	};
 }
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/plan.ts
-/** Wide, non-inverted band for the paired (non-swapping) call — never triggers a swap. */
-const WIDE_LIMITS = [Number(MIN_TICK) + 1, Number(MAX_TICK) - 1];
-/**
-* Convert a slippage tolerance in bps to a conservative Uniswap tick distance.
-*
-* Ticks are 1.0001^tick, so each tick ≈ 1 bps. This walks up powers of 1.0001
-* until the cumulative price move covers `slippageBps`, matching the hedger-bot's
-* dispatch-path helper so both swap paths agree on band width.
-*/
-function slippageBpsToTickDistance(slippageBps) {
-	if (slippageBps < 0n || slippageBps > 1000n) throw new PanopticError(`slippage bps ${slippageBps} out of bounds (0..1000)`);
-	if (slippageBps === 0n) return 0n;
-	let numerator = 1n;
-	let denominator = 1n;
-	let ticks = 0n;
-	while (numerator * 10000n < denominator * (10000n + slippageBps)) {
-		numerator *= 10001n;
-		denominator *= 10000n;
-		ticks += 1n;
-	}
-	return ticks;
+function getRawPriceRatio(tick) {
+	return getPriceRatioFromSqrtPriceX96(tickToSqrtPriceX96(tick));
+}
+function adjustRatioForDecimals(numerator, denominator, decimals0, decimals1) {
+	const diff = decimals0 - decimals1;
+	if (diff === 0n) return {
+		numerator,
+		denominator
+	};
+	if (diff > 0n) return {
+		numerator: numerator * pow10(diff),
+		denominator
+	};
+	return {
+		numerator,
+		denominator: denominator * pow10(-diff)
+	};
 }
 /**
-* Build the swap plan.
+* Convert a tick to a raw price string (no decimal adjustment).
+* Uses the formula: price = 1.0001^tick
 *
-* Mechanism (verified in the Phase 0 fork test):
-* - A single-leg **loan** tokenId (width=0, isLong=false, `asset == tokenType`) moves
-*   exactly `positionSize` of the `tokenType` token when its call carries inverted
-*   tick limits (`low > high`); the paired call uses a wide band and moves nothing.
-* - `exactIn`: swap on the **mint**; `tokenType` = the **input** token index.
-* - `exactOut`: swap on the **burn** (isLong flips → exact-output); `tokenType` = the
-*   **output** token index.
+* This returns the raw price ratio, not adjusted for token decimals.
+* A fixed internal precision is used and trailing zeros are trimmed.
 *
-* The inverted band is centered on `currentTick` at ±`slippageBpsToTickDistance`,
-* which the SFPM re-sorts and enforces as an open interval on the post-swap tick.
+* @param tick - The tick value
+* @returns Price string
+*
+* @example
+* ```typescript
+* tickToPrice(0n)       // "1"
+* tickToPrice(1000n)    // "1.105..." (approximately)
+* tickToPrice(-1000n)   // "0.904..." (approximately)
+* tickToPrice(200000n)  // Very large number
+* ```
 */
-function buildSfpmSwapPlan(params) {
-	const { sfpmAddress, poolAddress, poolId, kind, zeroForOne, amount, currentTick, slippageBps } = params;
-	if (amount <= 0n) throw new PanopticError(`swap amount must be positive (got ${amount})`);
-	const distance = slippageBpsToTickDistance(slippageBps);
-	if (distance < 1n) throw new PanopticError(`slippageBps ${slippageBps} yields a zero-width tick band; use a larger tolerance`);
-	const tokenType = kind === "exactIn" ? zeroForOne ? 0n : 1n : zeroForOne ? 1n : 0n;
-	const tokenId = createTokenIdBuilder(poolId).addLoan({
-		asset: tokenType,
-		tokenType,
-		strike: 0n
-	}).build();
-	const d = Number(distance);
-	const low = Math.min(Number(MAX_TICK), currentTick + d);
-	const high = Math.max(Number(MIN_TICK), currentTick - d);
-	if (low <= high) throw new PanopticError(`slippageBps ${slippageBps} at tick ${currentTick} yields a non-inverted band after clamping`);
-	const invertedLimits = [low, high];
-	const swapOn = kind === "exactIn" ? "mint" : "burn";
-	return {
-		sfpmAddress,
-		poolAddress,
-		poolKey: encodeAbiParameters([{ type: "address" }], [poolAddress]),
-		tokenId,
-		positionSize: amount,
-		mintTickLimits: swapOn === "mint" ? invertedLimits : WIDE_LIMITS,
-		burnTickLimits: swapOn === "burn" ? invertedLimits : WIDE_LIMITS,
-		swapOn,
-		kind
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/quote.ts
-const UINT128 = 1n << 128n;
-const INT128_MAX = (1n << 127n) - 1n;
-/** Extract the two signed 128-bit slots from a packed `LeftRightSigned` int256. */
-function unpackLeftRightSigned(packed) {
-	const u = packed < 0n ? packed + (1n << 256n) : packed;
-	const toInt128 = (half) => half > INT128_MAX ? half - UINT128 : half;
-	return {
-		right: toInt128(u & UINT128 - 1n),
-		left: toInt128(u >> 128n & UINT128 - 1n)
-	};
-}
-/** Wrap an unknown thrown value as a PanopticError, decoding Panoptic reverts when possible. */
-function toPanopticError(err) {
-	if (err instanceof PanopticError) return err;
-	const parsed = parsePanopticError(err);
-	if (parsed) return parsed.error;
-	return new PanopticError(err instanceof Error ? err.message : "SFPM swap simulation failed", err instanceof Error ? err : void 0);
+function tickToPrice(tick) {
+	const { numerator, denominator } = getRawPriceRatio(tick);
+	const price = formatRatio$3(numerator, denominator, RAW_PRICE_PRECISION);
+	return trimTrailingZeros(price);
 }
 /**
-* Quote a swap by simulating `SFPM.multicall([mint, burn])` and decoding the swap
-* call's `totalMoved` return. Authoritative — captures the width-0 loan-leg wei
-* rounding a raw QuoterV2 quote would miss.
+* Convert a tick to a human-readable price with decimal scaling.
+* Uses the formula: price = 1.0001^tick * 10^(decimals0-decimals1)
+*
+* This adjusts for the different decimals of the two tokens in the pair.
+*
+* @param tick - The tick value
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price string
+*
+* @example
+* ```typescript
+* // WETH/USDC pool (18 decimals / 6 decimals)
+* // At tick ~200000, price is roughly $2000 per ETH
+* tickToPriceDecimalScaled(200000n, 18n, 6n, 2n) // "2000.00" (approximately)
+*
+* // For token1/token0 price, swap the decimals
+* tickToPriceDecimalScaled(200000n, 6n, 18n, 6n) // "0.000500" (approximately)
+* ```
 */
-async function quoteSfpmSwap(params) {
-	const { client, plan, account, stateOverride, blockNumber } = params;
-	const { mintData, burnData } = buildSfpmSwapCalldata(plan);
-	const _meta = await getBlockMeta({
-		client,
-		blockNumber
-	});
-	try {
-		const { result } = await client.simulateContract({
-			account,
-			address: plan.sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "multicall",
-			args: [[mintData, burnData]],
-			blockNumber,
-			stateOverride
-		});
-		const swapIndex = plan.swapOn === "mint" ? 0 : 1;
-		const decoded = decodeFunctionResult({
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: plan.swapOn === "mint" ? "mintTokenizedPosition" : "burnTokenizedPosition",
-			data: result[swapIndex]
-		});
-		const finalTick = Number(decoded[2]);
-		const { right, left } = unpackLeftRightSigned(decoded[1]);
-		const inSlot = [right, left].find((s) => s > 0n);
-		const outSlot = [right, left].find((s) => s < 0n);
-		if (inSlot === void 0 || outSlot === void 0) return {
-			success: false,
-			error: new PanopticError(`SFPM swap simulation moved no tokens (totalMoved=${decoded[1]})`),
-			_meta
-		};
-		return {
-			success: true,
-			data: {
-				amountIn: inSlot,
-				amountOut: -outSlot,
-				finalTick
-			},
-			gasEstimate: 0n,
-			_meta
-		};
-	} catch (err) {
-		return {
-			success: false,
-			error: toPanopticError(err),
-			_meta
-		};
-	}
+function tickToPriceDecimalScaled(tick, decimals0, decimals1, precision) {
+	const rawRatio = getRawPriceRatio(tick);
+	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return formatRatio$3(numerator, denominator, precision);
 }
-
-//#endregion
-//#region src/uniswap/v4/abis/universalRouter.ts
 /**
-* Minimal Universal Router ABI (only the `execute` overload we use).
-* @module uniswap/v4/abis/universalRouter
+* Convert a sqrtPriceX96 to a human-readable price with decimal scaling.
+*
+* Uses the formula: price = (sqrtPriceX96^2 / 2^192) * 10^(decimals0-decimals1)
+*
+* @param sqrtPriceX96 - The sqrt price in Q64.96 format
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price string
+*
+* @example
+* ```typescript
+* sqrtPriceX96ToPriceDecimalScaled(2n ** 96n, 18n, 18n, 2n) // "1.00"
+* ```
 */
-const universalRouterAbi = [{
-	type: "function",
-	name: "execute",
-	stateMutability: "payable",
-	inputs: [
-		{
-			name: "commands",
-			type: "bytes"
-		},
-		{
-			name: "inputs",
-			type: "bytes[]"
-		},
-		{
-			name: "deadline",
-			type: "uint256"
-		}
-	],
-	outputs: []
-}];
-
-//#endregion
-//#region src/uniswap/v4/router/errors.ts
+function sqrtPriceX96ToPriceDecimalScaled(sqrtPriceX96, decimals0, decimals1, precision) {
+	const rawRatio = getPriceRatioFromSqrtPriceX96(sqrtPriceX96);
+	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return formatRatio$3(numerator, denominator, precision);
+}
 /**
-* The chain has no configured Uniswap v4 addresses and none were supplied via
-* overrides.
+* Convert a price to a tick value.
+*
+* @param price - The price string
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @returns The tick value (rounded to nearest integer)
+*
+* @example
+* ```typescript
+* // WETH/USDC: What tick for $2000 per ETH?
+* priceToTick("2000", 18n, 6n) // ~200000n
+*
+* // Inverse: What tick for 0.0005 ETH per USDC?
+* priceToTick("0.0005", 6n, 18n) // ~200000n
+* ```
 */
-var UnsupportedChainError = class extends PanopticError {
-	name = "UnsupportedChainError";
-	constructor(chainId, cause) {
-		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
-		this.chainId = chainId;
+function priceToTick(price, decimals0, decimals1) {
+	const parsed = parseDecimalToFraction(price);
+	if (parsed.numerator <= 0n) throw new Error("Price must be positive");
+	let targetNumerator = parsed.numerator;
+	let targetDenominator = parsed.denominator;
+	const diff = decimals0 - decimals1;
+	if (diff > 0n) targetDenominator *= pow10(diff);
+	else if (diff < 0n) targetNumerator *= pow10(-diff);
+	let low = MIN_TICK;
+	let high = MAX_TICK;
+	while (low <= high) {
+		const mid = (low + high) / 2n;
+		const { numerator, denominator } = getRawPriceRatio(mid);
+		const cmp = compareRatios(numerator, denominator, targetNumerator, targetDenominator);
+		if (cmp === 0) return mid;
+		if (cmp < 0) low = mid + 1n;
+		else high = mid - 1n;
 	}
-};
+	const floorTick = high;
+	const ceilTick = low;
+	if (floorTick < MIN_TICK) return MIN_TICK;
+	if (ceilTick > MAX_TICK) return MAX_TICK;
+	const floorRatio = getRawPriceRatio(floorTick);
+	const ceilRatio = getRawPriceRatio(ceilTick);
+	const floorDiffNumerator = absBigint(targetNumerator * floorRatio.denominator - floorRatio.numerator * targetDenominator);
+	const ceilDiffNumerator = absBigint(targetNumerator * ceilRatio.denominator - ceilRatio.numerator * targetDenominator);
+	const floorDiffDenominator = targetDenominator * floorRatio.denominator;
+	const ceilDiffDenominator = targetDenominator * ceilRatio.denominator;
+	return floorDiffNumerator * ceilDiffDenominator <= ceilDiffNumerator * floorDiffDenominator ? floorTick : ceilTick;
+}
 /**
-* `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
+* Convert a sqrtPriceX96 value to the nearest tick.
+*
+* @param sqrtPriceX96 - The sqrt price in Q64.96 format
+* @returns The tick value (rounded to nearest integer)
+*
+* @example
+* ```typescript
+* const tick = sqrtPriceX96ToTick(2n ** 96n) // 0n
+* ```
 */
-var InvalidSwapTokenError = class extends PanopticError {
-	name = "InvalidSwapTokenError";
-	constructor(token, currency0, currency1, cause) {
-		super(`Token ${token} is not part of the pool (currency0=${currency0}, currency1=${currency1})`, cause);
-		this.token = token;
-		this.currency0 = currency0;
-		this.currency1 = currency1;
-	}
-};
-/**
-* An amount exceeds the uint128 range required by the v4 swap encoding.
-*/
-var AmountExceedsUint128Error = class extends PanopticError {
-	name = "AmountExceedsUint128Error";
-	constructor(amount, cause) {
-		super(`Amount ${amount} exceeds uint128 maximum`, cause);
-		this.amount = amount;
-	}
-};
-/**
-* A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
-* output (or refund the input overpay), but no `recipient` was supplied.
-*/
-var MissingSweepRecipientError = class extends PanopticError {
-	name = "MissingSweepRecipientError";
-	constructor(cause) {
-		super("A recipient is required to sweep native ETH back to the user", cause);
-	}
-};
-/**
-* The V4Quoter is not available for the chain (no fallback in v1).
-*/
-var QuoterUnavailableError = class extends PanopticError {
-	name = "QuoterUnavailableError";
-	constructor(chainId, cause) {
-		super(`V4Quoter unavailable for chain ${chainId}`, cause);
-		this.chainId = chainId;
+function sqrtPriceX96ToTick(sqrtPriceX96) {
+	if (sqrtPriceX96 <= 0n) throw new Error("Sqrt price must be positive");
+	if (sqrtPriceX96 < MIN_SQRT_PRICE_X96 || sqrtPriceX96 > MAX_SQRT_PRICE_X96) throw new RangeError("Sqrt price out of bounds");
+	let low = MIN_TICK;
+	let high = MAX_TICK;
+	while (low <= high) {
+		const mid = (low + high) / 2n;
+		const midSqrt = tickToSqrtPriceX96(mid);
+		if (midSqrt === sqrtPriceX96) return mid;
+		if (midSqrt < sqrtPriceX96) low = mid + 1n;
+		else high = mid - 1n;
 	}
-};
-
-//#endregion
-//#region src/uniswap/v3/router/encodeSwap.ts
-const UINT128_MAX$4 = (1n << 128n) - 1n;
-
-//#endregion
-//#region src/uniswap/v3/abis/quoterV2.ts
+	const floorTick = high;
+	const ceilTick = low;
+	if (floorTick < MIN_TICK) return MIN_TICK;
+	if (ceilTick > MAX_TICK) return MAX_TICK;
+	const floorSqrt = tickToSqrtPriceX96(floorTick);
+	const ceilSqrt = tickToSqrtPriceX96(ceilTick);
+	const floorDiff = absBigint(sqrtPriceX96 - floorSqrt);
+	const ceilDiff = absBigint(ceilSqrt - sqrtPriceX96);
+	return floorDiff <= ceilDiff ? floorTick : ceilTick;
+}
 /**
-* Minimal Uniswap v3 QuoterV2 ABI (`quoteExactInputSingle`).
+* Format a tick value for display.
 *
-* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
-* `simulateContract`), so it must be simulated, not read.
-* @module uniswap/v3/abis/quoterV2
-*/
-const quoterV2Abi = [{
-	type: "function",
-	name: "quoteExactInputSingle",
-	stateMutability: "nonpayable",
-	inputs: [{
-		name: "params",
-		type: "tuple",
-		components: [
-			{
-				name: "tokenIn",
-				type: "address"
-			},
-			{
-				name: "tokenOut",
-				type: "address"
-			},
-			{
-				name: "amountIn",
-				type: "uint256"
-			},
-			{
-				name: "fee",
-				type: "uint24"
-			},
-			{
-				name: "sqrtPriceLimitX96",
-				type: "uint160"
-			}
-		]
-	}],
-	outputs: [
-		{
-			name: "amountOut",
-			type: "uint256"
-		},
-		{
-			name: "sqrtPriceX96After",
-			type: "uint160"
-		},
-		{
-			name: "initializedTicksCrossed",
-			type: "uint32"
-		},
-		{
-			name: "gasEstimate",
-			type: "uint256"
-		}
-	]
-}];
-
-//#endregion
-//#region src/uniswap/v3/addresses.ts
-/**
-* Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
-* after verifying against the canonical Uniswap v3 deployment listing.
+* @param tick - The tick value
+* @returns Formatted tick string
+*
+* @example
+* ```typescript
+* formatTick(200000n)  // "200000"
+* formatTick(-50000n)  // "-50000"
+* ```
 */
-const UNISWAP_V3_ADDRESSES = { 1: {
-	quoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-	nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
-} };
+function formatTick(tick) {
+	return tick.toString();
+}
 /**
-* Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+* Get the price at a specific tick, returning both token0/token1 and token1/token0 prices.
 *
-* @throws {UnsupportedChainError} when the chain is not listed and overrides do
-*   not supply every required address.
+* @param tick - The tick value
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Object with both price directions
+*
+* @example
+* ```typescript
+* const prices = getPricesAtTick(200000n, 18n, 6n, 2n)
+* // prices.token0PerToken1 = "0.00" (very small)
+* // prices.token1PerToken0 = "2000.00" (USDC per ETH)
+* ```
 */
-function getUniswapV3Addresses(chainId, overrides) {
-	const id = Number(chainId);
-	const base = UNISWAP_V3_ADDRESSES[id];
-	const merged = {
-		...base,
-		...overrides
+function getPricesAtTick(tick, decimals0, decimals1, precision) {
+	const rawRatio = getRawPriceRatio(tick);
+	const adjustedRatio = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return {
+		token0PerToken1: formatRatio$3(adjustedRatio.denominator, adjustedRatio.numerator, precision),
+		token1PerToken0: formatRatio$3(adjustedRatio.numerator, adjustedRatio.denominator, precision)
 	};
-	if (!merged.quoterV2 || !merged.nonfungiblePositionManager) throw new UnsupportedChainError(BigInt(id));
-	return merged;
 }
-
-//#endregion
-//#region src/uniswap/v3/router/quote.ts
-const BPS_DENOMINATOR$5 = 10000n;
-const UINT128_MAX$3 = (1n << 128n) - 1n;
 /**
-* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
-* pool does not exist / has no liquidity) so callers can skip that pool when
-* ranking venues, rather than aborting the whole cycle.
+* Format a tick range for display.
+*
+* @param tickLower - Lower tick
+* @param tickUpper - Upper tick
+* @returns Formatted tick range string
+*
+* @example
+* ```typescript
+* formatTickRange(-50000n, 200000n) // "-50000 - 200000"
+* ```
 */
-async function quoteV3ExactIn(params) {
-	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
-	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
-	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$5) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
-	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
-	try {
-		const { result } = await client.simulateContract({
-			address: quoterV2,
-			abi: quoterV2Abi,
-			functionName: "quoteExactInputSingle",
-			blockNumber,
-			args: [{
-				tokenIn,
-				tokenOut,
-				amountIn,
-				fee: Number(fee),
-				sqrtPriceLimitX96: 0n
-			}]
-		});
-		const [amountOut, , , gasEstimate] = result;
-		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$5 - slippageBps) / BPS_DENOMINATOR$5;
-		return {
-			amountOut,
-			amountOutMinimum,
-			gasEstimate
-		};
-	} catch (err) {
-		if (isRevert(err)) return null;
-		throw err;
-	}
-}
-/** True only for genuine contract reverts (missing pool / no liquidity). */
-function isRevert(err) {
-	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+function formatTickRange(tickLower, tickUpper) {
+	return `${tickLower} - ${tickUpper}`;
 }
-
-//#endregion
-//#region src/panoptic/v2/reads/sfpm.ts
 /**
-* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
+* Format a price range for display.
 *
-* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
+* @param tickLower - Lower tick
+* @param tickUpper - Upper tick
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price range string
+*
+* @example
+* ```typescript
+* formatPriceRange(0n, 0n, 18n, 18n, 2n) // "1.00 - 1.00"
+* ```
 */
-async function getUniswapV3PoolFromId(params) {
-	const { client, sfpmAddress, poolId } = params;
-	return client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
-	});
+function formatPriceRange(tickLower, tickUpper, decimals0, decimals1, precision) {
+	const lower = tickToPriceDecimalScaled(tickLower, decimals0, decimals1, precision);
+	const upper = tickToPriceDecimalScaled(tickUpper, decimals0, decimals1, precision);
+	return `${lower} - ${upper}`;
 }
 /**
-* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
+* Calculate the tick spacing for a given fee tier.
 *
-* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
-*/
-async function getUniswapV4PoolKeyFromId(params) {
-	const { client, sfpmAddress, poolId } = params;
-	const raw = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV4Abi,
-		functionName: "getUniswapV4PoolKeyFromId",
-		args: [poolId]
-	});
-	return {
-		currency0: raw.currency0,
-		currency1: raw.currency1,
-		fee: BigInt(raw.fee),
-		tickSpacing: BigInt(raw.tickSpacing),
-		hooks: raw.hooks
-	};
+* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
+* @returns Tick spacing
+*
+* @example
+* ```typescript
+* getTickSpacing(100n)  // 1n (0.01% fee tier)
+* getTickSpacing(500n)  // 10n (0.05% fee tier)
+* getTickSpacing(3000n) // 60n (0.30% fee tier)
+* getTickSpacing(10000n) // 200n (1.00% fee tier)
+* ```
+*/
+function getTickSpacing(feeBps) {
+	switch (feeBps) {
+		case 100n: return 1n;
+		case 500n: return 10n;
+		case 3000n: return 60n;
+		case 10000n: return 200n;
+		default: {
+			const spacing = feeBps / 50n;
+			return spacing > 1n ? spacing : 1n;
+		}
+	}
 }
 /**
-* Get the enforced tick limits for a pool from the SFPM.
+* Round a tick to the nearest valid tick for a given tick spacing.
 *
-* @param params - The parameters
-* @returns The min and max enforced ticks
+* @param tick - The tick to round
+* @param tickSpacing - The tick spacing
+* @returns Rounded tick
+*
+* @example
+* ```typescript
+* roundToTickSpacing(12345n, 10n) // 12340n
+* roundToTickSpacing(12345n, 60n) // 12360n
+* roundToTickSpacing(-12345n, 10n) // -12350n
+* ```
 */
-async function getEnforcedTickLimits(params) {
-	const { client, sfpmAddress, poolId } = params;
-	const [minTick, maxTick] = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV4Abi,
-		functionName: "getEnforcedTickLimits",
-		args: [poolId]
-	});
-	return {
-		minEnforcedTick: minTick,
-		maxEnforcedTick: maxTick
-	};
+function roundToTickSpacing(tick, tickSpacing) {
+	const remainder = tick % tickSpacing;
+	if (remainder === 0n) return tick;
+	if (tick >= 0n) return remainder >= tickSpacing / 2n ? tick + (tickSpacing - remainder) : tick - remainder;
+	const absRemainder = -remainder;
+	return absRemainder >= tickSpacing / 2n ? tick - (tickSpacing - absRemainder) : tick + absRemainder;
 }
 /**
-* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
+* Compute slippage-bounded tick limits around the current tick.
 *
-* Uses multicall for efficiency. Returns one result per input chunk,
-* along with block metadata for freshness tracking.
+* 1 tick ≈ 1 basis point (0.01 %) of price change, so a `toleranceBps`
+* of 500 allows roughly 5 % price movement.  The result is clamped to
+* the protocol's `[MIN_TICK, MAX_TICK]` range.
+*
+* Useful for setting `tickLimitLow` / `tickLimitHigh` on `openPosition`
+* and `closePosition` to protect against MEV sandwiches and volatile
+* tick moves.
+*
+* @param currentTick - The current pool tick (must be within [MIN_TICK, MAX_TICK]).
+* @param toleranceBps - Slippage tolerance in basis points (≈ ticks). Must be non-negative.
+* @returns Clamped `{ low, high }` tick limits.
+* @throws {RangeError} If `toleranceBps` is negative or `currentTick` is out of bounds.
+*
+* @example
+* ```typescript
+* const { low, high } = tickLimits(200_000n, 500n)
+* // low  = 199_500n
+* // high = 200_500n
+*
+* await openPosition({ ..., tickLimitLow: low, tickLimitHigh: high })
+* ```
 */
-async function getChunkLiquidities(params) {
-	const { client, sfpmAddress, poolKeyBytes, chunks } = params;
-	if (chunks.length > MAX_TRACKED_CHUNKS) throw new ChunkLimitError(BigInt(chunks.length), 0n);
-	const _meta = params._meta ?? await getBlockMeta({ client });
-	if (chunks.length === 0) return {
-		results: [],
-		_meta
-	};
-	const multicallResults = await client.multicall({
-		contracts: chunks.map((chunk) => ({
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV4Abi,
-			functionName: "getAccountLiquidity",
-			args: [
-				poolKeyBytes,
-				chunk.owner,
-				chunk.tokenType,
-				Number(chunk.tickLower),
-				Number(chunk.tickUpper)
-			]
-		})),
-		allowFailure: true
-	});
-	const results = multicallResults.map((result) => {
-		if (result.status === "failure") return {
-			netLiquidity: 0n,
-			removedLiquidity: 0n,
-			totalLiquidity: 0n,
-			shortLiquidity: 0n,
-			longLiquidity: 0n
-		};
-		const packed = result.result;
-		const netLiquidity = packed & (1n << 128n) - 1n;
-		const removedLiquidity = packed >> 128n;
-		const totalLiquidity = netLiquidity + removedLiquidity;
-		return {
-			netLiquidity,
-			removedLiquidity,
-			totalLiquidity,
-			shortLiquidity: totalLiquidity,
-			longLiquidity: removedLiquidity
-		};
-	});
+function tickLimits(currentTick, toleranceBps) {
+	if (toleranceBps < 0n) throw new RangeError(`toleranceBps must be non-negative, got ${toleranceBps}`);
+	if (currentTick < MIN_TICK || currentTick > MAX_TICK) throw new RangeError(`currentTick ${currentTick} is out of bounds [${MIN_TICK}, ${MAX_TICK}]`);
+	const rawLow = currentTick - toleranceBps;
+	const rawHigh = currentTick + toleranceBps;
+	const low = rawLow < MIN_TICK ? MIN_TICK : rawLow;
+	const high = rawHigh > MAX_TICK ? MAX_TICK : rawHigh;
+	if (low > high) throw new RangeError(`Computed tick limits are inverted: low ${low} > high ${high} (currentTick=${currentTick}, toleranceBps=${toleranceBps})`);
 	return {
-		results,
-		_meta
+		low,
+		high
 	};
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/factory.ts
+//#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
+const POOL_ID_MASK$2 = (1n << 64n) - 1n;
+const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
+const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
+const Q192$3 = 1n << 192n;
 /**
-* Get the token URI from a PanopticFactory NFT.
+* Floor integer square root for bigints (Newton's method). Mirrors the isqrt
+* used in reads/collateralEstimate.ts (buildNeutralLeg).
 */
-async function getFactoryTokenURI(params) {
-	const { client, factoryAddress, version, tokenId } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "tokenURI",
-		args: [tokenId]
-	});
+function isqrt$1(value) {
+	if (value < 0n) throw new PanopticError("isqrt of negative number");
+	if (value < 2n) return value;
+	let x = value;
+	let y = x + 1n >> 1n;
+	while (y < x) {
+		x = y;
+		y = x + value / x >> 1n;
+	}
+	return x;
 }
-/**
-* Get the owner of a PanopticFactory NFT.
-*/
-async function getFactoryOwnerOf(params) {
-	const { client, factoryAddress, version, tokenId } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "ownerOf",
-		args: [tokenId]
+const DEFAULT_TICK_SPACING = 200n;
+/**
+* Target notional (in wei of the tokenType-side asset) for the appended
+* tiny credit leg. Chosen at 10 wei — small enough to be economically
+* meaningless against any real position size, large enough to safely
+* clear rounding on the SFPM's width-2 internal chunk math without any
+* risk of underflowing to zero (which would revert ChunkHasZeroLiquidity).
+*/
+const TINY_CREDIT_TARGET_NOTIONAL_WEI = 10n;
+/**
+* Pick a signedStrike for the appended width=0 credit leg such that:
+*   1. positionSize · 1.0001^signedStrike ≈ TINY_CREDIT_TARGET_NOTIONAL_WEI
+*      (~10 wei — economically meaningless but comfortably above any
+*      SFPM width-2 chunk rounding);
+*   2. the leg's tick range (SFPM internally treats width=0 as width=2, so
+*      the range is `strike ± tickSpacing`) stays strictly inside
+*      `[MIN_POOL_TICK, MAX_POOL_TICK]` — otherwise the getSqrtRatioAtTick
+*      call reverts with `InvalidTick`.
+*
+* Closed form: `1.0001^signedStrike = target/positionSize`, so
+* `sqrtKrawX96 = isqrt(target · 2^192 / positionSize)` and
+* `signedStrike = sqrtPriceX96ToTick(sqrtKrawX96)`. If the notional-optimal
+* strike falls outside the safe range, we clamp inward. Clamping raises the
+* notional but keeps it << position size for any reasonable strike.
+*/
+function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
+	if (positionSize <= 0n) throw new PanopticError("computeTinyCreditSignedStrike: positionSize must be > 0");
+	const minSafe = MIN_TICK + tickSpacing + 1n;
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike;
+	try {
+		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$3 / positionSize);
+		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
+	} catch {
+		signedStrike = minSafe;
+	}
+	if (signedStrike < minSafe) return minSafe;
+	if (signedStrike > maxSafe) return maxSafe;
+	return signedStrike;
+}
+/**
+* Assemble the tiny credit leg struct, picking a strike that avoids
+* colliding with any existing width=0 credit leg on the same (asset,
+* tokenType) pair.
+*
+* The encoded strike stored in the tokenId is
+* `asset === 0 ? signedStrike : -signedStrike` (mirrors
+* {@link buildNeutralLeg} in reads/collateralEstimate.ts).
+*/
+function pickUniqueTinyCreditLeg(baseTokenId, legIndex, positionSize, tickSpacing) {
+	const asset = 1n;
+	const tokenType = 0n;
+	const existingLegs = decodeAllLegs(baseTokenId);
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike = computeTinyCreditSignedStrike(positionSize, tickSpacing);
+	while (signedStrike <= maxSafe) {
+		const candidate = asset === 0n ? signedStrike : -signedStrike;
+		let collides = false;
+		for (const leg of existingLegs) if (leg.width === 0n && leg.isLong && leg.asset === asset && leg.tokenType === tokenType && leg.strike === candidate) {
+			collides = true;
+			break;
+		}
+		if (!collides) break;
+		signedStrike += 1n;
+	}
+	if (signedStrike > maxSafe) throw new PanopticError("deriveUniqueTokenId: exhausted strike space picking a unique tiny credit leg");
+	const encodedStrike = asset === 0n ? signedStrike : -signedStrike;
+	return {
+		index: legIndex,
+		asset,
+		tokenType,
+		optionRatio: 1n,
+		isLong: 1n,
+		riskPartner: legIndex,
+		strike: encodedStrike,
+		width: 0n
+	};
+}
+function appendTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing) {
+	const newLeg = pickUniqueTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing);
+	return addLegToTokenId(baseTokenId, newLeg);
+}
+function scaleRatios(baseTokenId, targetPositionSize) {
+	const legs = decodeAllLegs(baseTokenId);
+	const maxRatio = legs.reduce((m, leg) => leg.optionRatio > m ? leg.optionRatio : m, 0n);
+	const N = MAX_OPTION_RATIO / maxRatio;
+	if (N < 2n) throw new PanopticError("deriveUniqueTokenId: cannot derive a unique tokenId — all 4 leg slots used and optionRatios already near the 127 ceiling");
+	const newPositionSize = (targetPositionSize + N - 1n) / N;
+	const poolId = baseTokenId & POOL_ID_MASK$2;
+	let out = poolId;
+	for (const leg of legs) out = addLegToTokenId(out, {
+		index: leg.index,
+		asset: leg.asset,
+		tokenType: leg.tokenType,
+		optionRatio: leg.optionRatio * N,
+		isLong: leg.isLong ? 1n : 0n,
+		riskPartner: leg.riskPartner,
+		strike: leg.strike,
+		width: leg.width
 	});
+	return {
+		newTokenId: out,
+		newPositionSize,
+		effectivePositionSize: newPositionSize * N,
+		strategy: "ratio-scale"
+	};
 }
 /**
-* Construct NFT metadata for a pool via the factory contract.
+* Derive a tokenId unique from `baseTokenId` for a partial reduction.
+*
+* Prefers a tiny-credit-leg extension (arbitrary new size). Falls back to
+* optionRatio scaling only when the base tokenId already occupies all 4 leg
+* slots.
 */
-async function getFactoryConstructMetadata(params) {
-	const { client, factoryAddress, version, panopticPoolAddress, symbol0, symbol1, fee } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "constructMetadata",
-		args: [
-			panopticPoolAddress,
-			symbol0,
-			symbol1,
-			fee
-		]
-	});
+function deriveUniqueTokenId(params) {
+	const { baseTokenId, targetPositionSize, tickSpacing = DEFAULT_TICK_SPACING } = params;
+	if (targetPositionSize <= 0n) throw new PanopticError("deriveUniqueTokenId: targetPositionSize must be > 0");
+	const legCount = countLegs(baseTokenId);
+	if (legCount === 0n) throw new PanopticError("deriveUniqueTokenId: baseTokenId has no legs");
+	if (legCount < MAX_LEGS) {
+		const newTokenId = appendTinyCreditLeg(baseTokenId, legCount, targetPositionSize, tickSpacing);
+		return {
+			newTokenId,
+			newPositionSize: targetPositionSize,
+			effectivePositionSize: targetPositionSize,
+			strategy: "tiny-credit"
+		};
+	}
+	return scaleRatios(baseTokenId, targetPositionSize);
 }
 /**
-* Get the PanopticPool address for a given pool and risk engine.
+* Re-export decoded leg count so callers can gate UI on the strategy that
+* would be chosen (e.g. show a divisibility hint on ratio-scale positions).
 */
-async function getPanopticPoolAddress(params) {
-	const { client, factoryAddress, riskEngine } = params;
-	if (params.version === "v3") return client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV3Abi,
-		functionName: "getPanopticPool",
-		args: [params.univ3pool, riskEngine]
-	});
-	return client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "getPanopticPool",
-		args: [{
-			currency0: params.poolKey.currency0,
-			currency1: params.poolKey.currency1,
-			fee: Number(params.poolKey.fee),
-			tickSpacing: Number(params.poolKey.tickSpacing),
-			hooks: params.poolKey.hooks
-		}, riskEngine]
-	});
+function planDeriveStrategy(baseTokenId) {
+	return countLegs(baseTokenId) < MAX_LEGS ? "tiny-credit" : "ratio-scale";
 }
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/calldata.ts
 /**
-* Mine for an optimal pool address salt with high rarity.
+* Encode the `multicall([mint, burn])` for a swap plan.
+*
+* The order is always `[mint, burn]` — the ERC1155 must be minted before it is
+* burned. Which call carries the inverted (swap) limits is decided in the plan.
 */
-async function minePoolAddress(params) {
-	const { client, factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
-	let result;
-	if (params.version === "v3") result = await client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV3Abi,
-		functionName: "minePoolAddress",
+function buildSfpmSwapCalldata(plan) {
+	const mintData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "mintTokenizedPosition",
 		args: [
-			deployerAddress,
-			params.v3Pool,
-			riskEngine,
-			salt,
-			loops,
-			minTargetRarity
+			plan.poolKey,
+			plan.tokenId,
+			plan.positionSize,
+			plan.mintTickLimits[0],
+			plan.mintTickLimits[1]
 		]
 	});
-	else result = await client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "minePoolAddress",
+	const burnData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "burnTokenizedPosition",
 		args: [
-			deployerAddress,
-			{
-				currency0: params.poolKey.currency0,
-				currency1: params.poolKey.currency1,
-				fee: Number(params.poolKey.fee),
-				tickSpacing: Number(params.poolKey.tickSpacing),
-				hooks: params.poolKey.hooks
-			},
-			riskEngine,
-			salt,
-			loops,
-			minTargetRarity
+			plan.poolKey,
+			plan.tokenId,
+			plan.positionSize,
+			plan.burnTickLimits[0],
+			plan.burnTickLimits[1]
 		]
 	});
+	const multicallData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "multicall",
+		args: [[mintData, burnData]]
+	});
 	return {
-		bestSalt: BigInt(result[0]),
-		highestRarity: result[1]
+		multicallData,
+		mintData,
+		burnData
 	};
 }
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/init.ts
 /**
-* Simulate a pool deployment to get the predicted pool address.
+* Resolve the `uint64` SFPM poolId for a Uniswap v3 pool, initializing it if needed.
 *
-* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
-* without actually executing the transaction.
+* `initializeAMMPool` is permissionless and idempotent and **returns the poolId**
+* whether or not the pool was already registered, so a `simulateContract` call is
+* enough to learn the id without sending a transaction. Always resolve the id this
+* way rather than encoding it offline — the SFPM can collision-increment ids.
 */
-async function simulateDeployNewPool(params) {
-	const { client, factoryAddress, account, riskEngine, salt } = params;
-	if (params.version === "v3") {
-		const { result: result$1 } = await client.simulateContract({
-			address: factoryAddress,
-			abi: panopticFactoryV3Abi,
-			functionName: "deployNewPool",
-			args: [
-				params.token0,
-				params.token1,
-				Number(params.fee),
-				riskEngine,
-				salt
-			],
-			account
-		});
-		return result$1;
-	}
+async function fetchSfpmV3PoolId(params) {
+	const { client, sfpmAddress, token0, token1, fee } = params;
+	const vegoid$1 = params.vegoid ?? Number(DEFAULT_VEGOID);
 	const { result } = await client.simulateContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "deployNewPool",
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "initializeAMMPool",
 		args: [
-			{
-				currency0: params.poolKey.currency0,
-				currency1: params.poolKey.currency1,
-				fee: Number(params.poolKey.fee),
-				tickSpacing: Number(params.poolKey.tickSpacing),
-				hooks: params.poolKey.hooks
-			},
-			riskEngine,
-			salt
-		],
-		account
+			token0,
+			token1,
+			fee,
+			vegoid$1
+		]
 	});
-	return result;
+	return BigInt(result);
 }
 /**
-* Resolve an SFPM poolId to its PanopticPool address.
+* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
+* only if it is not already registered. Returns the resolved poolId.
 *
-* Chains two on-chain lookups:
-* 1. SFPM: poolId → Uniswap pool address (V3) or pool key (V4)
-* 2. Factory: Uniswap pool + riskEngine → PanopticPool address
+* When `expectedPool` is given, the resolved id is checked to map back to it via
+* `getUniswapV3PoolFromId` — guards against a wrong token/fee triple.
 */
-async function getPanopticPoolFromPoolId(params) {
-	const { client, sfpmAddress, factoryAddress, riskEngine, poolId, version } = params;
-	if (version === "v3") {
-		const univ3pool = await getUniswapV3PoolFromId({
-			client,
-			sfpmAddress,
-			poolId
-		});
-		return getPanopticPoolAddress({
-			version: "v3",
-			client,
-			factoryAddress,
-			univ3pool,
-			riskEngine
-		});
-	}
-	const poolKey = await getUniswapV4PoolKeyFromId({
+async function ensureSfpmV3PoolInitialized(params) {
+	const { client, wallet, sfpmAddress, token0, token1, fee, expectedPool } = params;
+	const vegoid$1 = params.vegoid ?? Number(DEFAULT_VEGOID);
+	const poolId = await fetchSfpmV3PoolId({
 		client,
 		sfpmAddress,
-		poolId
+		token0,
+		token1,
+		fee,
+		vegoid: vegoid$1
 	});
-	return getPanopticPoolAddress({
-		version: "v4",
-		client,
-		factoryAddress,
-		poolKey,
-		riskEngine
+	const registered = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
 	});
+	let initialized = false;
+	let resolved = registered;
+	if (getAddress(registered) === zeroAddress) {
+		const account = wallet.account;
+		if (account === void 0) throw new PanopticError("wallet client has no account");
+		const hash = await wallet.writeContract({
+			account,
+			chain: wallet.chain ?? null,
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "initializeAMMPool",
+			args: [
+				token0,
+				token1,
+				fee,
+				vegoid$1
+			]
+		});
+		await client.waitForTransactionReceipt({ hash });
+		initialized = true;
+		resolved = await client.readContract({
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "getUniswapV3PoolFromId",
+			args: [poolId]
+		});
+	}
+	if (expectedPool !== void 0 && getAddress(resolved) !== getAddress(expectedPool)) throw new WrongUniswapPoolError(new PanopticError(`SFPM poolId ${poolId} resolves to ${resolved}, expected ${expectedPool}`));
+	return {
+		poolId,
+		initialized
+	};
 }
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/plan.ts
+/** Wide, non-inverted band for the paired (non-swapping) call — never triggers a swap. */
+const WIDE_LIMITS = [Number(MIN_TICK) + 1, Number(MAX_TICK) - 1];
 /**
-* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
+* Convert a slippage tolerance in bps to a conservative Uniswap tick distance.
 *
-* Tries both V3 and V4 lookups in parallel. The factory returns `address(0)` for
-* non-existent pools, so the non-zero result identifies the correct version.
+* Ticks are 1.0001^tick, so each tick ≈ 1 bps. This walks up powers of 1.0001
+* until the cumulative price move covers `slippageBps`, matching the hedger-bot's
+* dispatch-path helper so both swap paths agree on band width.
+*/
+function slippageBpsToTickDistance(slippageBps) {
+	if (slippageBps < 0n || slippageBps > 1000n) throw new PanopticError(`slippage bps ${slippageBps} out of bounds (0..1000)`);
+	if (slippageBps === 0n) return 0n;
+	let numerator = 1n;
+	let denominator = 1n;
+	let ticks = 0n;
+	while (numerator * 10000n < denominator * (10000n + slippageBps)) {
+		numerator *= 10001n;
+		denominator *= 10000n;
+		ticks += 1n;
+	}
+	return ticks;
+}
+/**
+* Build the swap plan.
 *
-* At least one of `v3` or `v4` must be provided.
+* Mechanism (verified in the Phase 0 fork test):
+* - A single-leg **loan** tokenId (width=0, isLong=false, `asset == tokenType`) moves
+*   exactly `positionSize` of the `tokenType` token when its call carries inverted
+*   tick limits (`low > high`); the paired call uses a wide band and moves nothing.
+* - `exactIn`: swap on the **mint**; `tokenType` = the **input** token index.
+* - `exactOut`: swap on the **burn** (isLong flips → exact-output); `tokenType` = the
+*   **output** token index.
 *
-* @throws {PanopticValidationError} If no version config is provided or neither resolves.
+* The inverted band is centered on `currentTick` at ±`slippageBpsToTickDistance`,
+* which the SFPM re-sorts and enforces as an open interval on the post-swap tick.
 */
-async function resolvePanopticPoolFromPoolId(params) {
-	const { client, poolId, riskEngine, v3, v4 } = params;
-	if (!v3 && !v4) throw new Error("At least one of v3 or v4 must be provided");
-	const isNotFoundError = (err) => {
-		if (typeof err === "object" && err !== null && "name" in err) {
-			const name = err.name;
-			return name === "ContractFunctionExecutionError" || name === "ContractFunctionRevertedError";
-		}
-		return false;
+function buildSfpmSwapPlan(params) {
+	const { sfpmAddress, poolAddress, poolId, kind, zeroForOne, amount, currentTick, slippageBps } = params;
+	if (amount <= 0n) throw new PanopticError(`swap amount must be positive (got ${amount})`);
+	const distance = slippageBpsToTickDistance(slippageBps);
+	if (distance < 1n) throw new PanopticError(`slippageBps ${slippageBps} yields a zero-width tick band; use a larger tolerance`);
+	const tokenType = kind === "exactIn" ? zeroForOne ? 0n : 1n : zeroForOne ? 1n : 0n;
+	const tokenId = createTokenIdBuilder(poolId).addLoan({
+		asset: tokenType,
+		tokenType,
+		strike: 0n
+	}).build();
+	const d = Number(distance);
+	const low = Math.min(Number(MAX_TICK), currentTick + d);
+	const high = Math.max(Number(MIN_TICK), currentTick - d);
+	if (low <= high) throw new PanopticError(`slippageBps ${slippageBps} at tick ${currentTick} yields a non-inverted band after clamping`);
+	const invertedLimits = [low, high];
+	const swapOn = kind === "exactIn" ? "mint" : "burn";
+	return {
+		sfpmAddress,
+		poolAddress,
+		poolKey: encodeAbiParameters([{ type: "address" }], [poolAddress]),
+		tokenId,
+		positionSize: amount,
+		mintTickLimits: swapOn === "mint" ? invertedLimits : WIDE_LIMITS,
+		burnTickLimits: swapOn === "burn" ? invertedLimits : WIDE_LIMITS,
+		swapOn,
+		kind
 	};
-	const results = await Promise.all([v3 ? getPanopticPoolFromPoolId({
-		version: "v3",
-		client,
-		sfpmAddress: v3.sfpmAddress,
-		factoryAddress: v3.factoryAddress,
-		riskEngine,
-		poolId
-	}).catch((err) => {
-		if (isNotFoundError(err)) return zeroAddress;
-		throw err;
-	}) : Promise.resolve(zeroAddress), v4 ? getPanopticPoolFromPoolId({
-		version: "v4",
-		client,
-		sfpmAddress: v4.sfpmAddress,
-		factoryAddress: v4.factoryAddress,
-		riskEngine,
-		poolId
-	}).catch((err) => {
-		if (isNotFoundError(err)) return zeroAddress;
-		throw err;
-	}) : Promise.resolve(zeroAddress)]);
-	const [v3Result, v4Result] = results;
-	if (v3Result !== zeroAddress) return {
-		panopticPoolAddress: v3Result,
-		version: "v3"
-	};
-	if (v4Result !== zeroAddress) return {
-		panopticPoolAddress: v4Result,
-		version: "v4"
-	};
-	throw new Error(`No PanopticPool found for poolId ${poolId}`);
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
+//#region src/panoptic/v2/sfpmSwap/quote.ts
+const UINT128 = 1n << 128n;
+const INT128_MAX = (1n << 127n) - 1n;
+/** Extract the two signed 128-bit slots from a packed `LeftRightSigned` int256. */
+function unpackLeftRightSigned(packed) {
+	const u = packed < 0n ? packed + (1n << 256n) : packed;
+	const toInt128 = (half) => half > INT128_MAX ? half - UINT128 : half;
+	return {
+		right: toInt128(u & UINT128 - 1n),
+		left: toInt128(u >> 128n & UINT128 - 1n)
+	};
+}
+/** Wrap an unknown thrown value as a PanopticError, decoding Panoptic reverts when possible. */
+function toPanopticError(err) {
+	if (err instanceof PanopticError) return err;
+	const parsed = parsePanopticError(err);
+	if (parsed) return parsed.error;
+	return new PanopticError(err instanceof Error ? err.message : "SFPM swap simulation failed", err instanceof Error ? err : void 0);
+}
 /**
-* keccak256 of the CREATE3 proxy initcode used by ClonesWithImmutableArgs.
-* Source: packages/panoptic-v2-core/lib/clones-with-immutable-args/src/ClonesWithImmutableArgs.sol
+* Quote a swap by simulating `SFPM.multicall([mint, burn])` and decoding the swap
+* call's `totalMoved` return. Authoritative — captures the width-0 loan-leg wei
+* rounding a raw QuoterV2 quote would miss.
 */
-const CREATE3_PROXY_BYTECODE_HASH = "0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f";
-const MASK_80 = (1n << 80n) - 1n;
-const MASK_40 = (1n << 40n) - 1n;
-const MASK_96 = (1n << 96n) - 1n;
-/** Encode a BigInt as a big-endian fixed-length byte array. */
-function bigintToBytes(value, byteLength) {
-	const bytes = new Uint8Array(byteLength);
-	let v = value;
-	for (let i = byteLength - 1; i >= 0; i--) {
-		bytes[i] = Number(v & 0xffn);
-		v >>= 8n;
+async function quoteSfpmSwap(params) {
+	const { client, plan, account, stateOverride, blockNumber } = params;
+	const { mintData, burnData } = buildSfpmSwapCalldata(plan);
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	try {
+		const { result } = await client.simulateContract({
+			account,
+			address: plan.sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "multicall",
+			args: [[mintData, burnData]],
+			blockNumber,
+			stateOverride
+		});
+		const swapIndex = plan.swapOn === "mint" ? 0 : 1;
+		const decoded = decodeFunctionResult({
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: plan.swapOn === "mint" ? "mintTokenizedPosition" : "burnTokenizedPosition",
+			data: result[swapIndex]
+		});
+		const finalTick = Number(decoded[2]);
+		const { right, left } = unpackLeftRightSigned(decoded[1]);
+		const inSlot = [right, left].find((s) => s > 0n);
+		const outSlot = [right, left].find((s) => s < 0n);
+		if (inSlot === void 0 || outSlot === void 0) return {
+			success: false,
+			error: new PanopticError(`SFPM swap simulation moved no tokens (totalMoved=${decoded[1]})`),
+			_meta
+		};
+		return {
+			success: true,
+			data: {
+				amountIn: inSlot,
+				amountOut: -outSlot,
+				finalTick
+			},
+			gasEstimate: 0n,
+			_meta
+		};
+	} catch (err) {
+		return {
+			success: false,
+			error: toPanopticError(err),
+			_meta
+		};
 	}
-	return bytes;
-}
-/** Parse a 0x-prefixed address into 20 bytes. */
-function addressToBytes(addr) {
-	const hex = addr.slice(2).padStart(40, "0");
-	const bytes = new Uint8Array(20);
-	for (let i = 0; i < 20; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-	return bytes;
-}
-/** Parse a 0x-prefixed 32-byte hex string into bytes. */
-function hex32ToBytes(hex) {
-	const h = hex.slice(2).padStart(64, "0");
-	const bytes = new Uint8Array(32);
-	for (let i = 0; i < 32; i++) bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-	return bytes;
 }
+
+//#endregion
+//#region src/uniswap/v4/abis/universalRouter.ts
 /**
-* Compute the CREATE3 deployed address for a given factory and packed salt.
-*
-* Mirrors `ClonesWithImmutableArgs.addressOfClone3(salt)` (with `address(this)` = factory):
-*   proxy    = CREATE2(factory, salt, PROXY_BYTECODE_HASH)
-*   deployed = CREATE1(proxy, nonce=1)
-*
-* Returns the deployed address as a uint160 BigInt.
+* Minimal Universal Router ABI (only the `execute` overload we use).
+* @module uniswap/v4/abis/universalRouter
 */
-function addressOfClone3(factory, salt) {
-	const saltBytes = bigintToBytes(salt, 32);
-	const create2Input = new Uint8Array(85);
-	create2Input[0] = 255;
-	create2Input.set(addressToBytes(factory), 1);
-	create2Input.set(saltBytes, 21);
-	create2Input.set(hex32ToBytes(CREATE3_PROXY_BYTECODE_HASH), 53);
-	const proxyHash = keccak256(create2Input, "bytes");
-	const proxyAddress = proxyHash.slice(12);
-	const create1Input = new Uint8Array(23);
-	create1Input[0] = 214;
-	create1Input[1] = 148;
-	create1Input.set(proxyAddress, 2);
-	create1Input[22] = 1;
-	const deployedHash = keccak256(create1Input, "bytes");
-	let addr = 0n;
-	for (let i = 12; i < 32; i++) addr = addr << 8n | BigInt(deployedHash[i]);
-	return addr;
-}
+const universalRouterAbi = [{
+	type: "function",
+	name: "execute",
+	stateMutability: "payable",
+	inputs: [
+		{
+			name: "commands",
+			type: "bytes"
+		},
+		{
+			name: "inputs",
+			type: "bytes[]"
+		},
+		{
+			name: "deadline",
+			type: "uint256"
+		}
+	],
+	outputs: []
+}];
+
+//#endregion
+//#region src/uniswap/v4/router/errors.ts
 /**
-* Count leading hex-zero characters in a 160-bit address value.
-*
-* Mirrors `PanopticMath.numberOfLeadingHexZeros(addr)`.
-* Returns 40 for the zero address.
+* The chain has no configured Uniswap v4 addresses and none were supplied via
+* overrides.
 */
-function numberOfLeadingHexZeros(addrInt) {
-	if (addrInt === 0n) return 40;
-	let x = addrInt;
-	let r = 0;
-	if (x >= 0x100000000000000000000000000000000n) {
-		x >>= 128n;
-		r += 32;
-	}
-	if (x >= 0x10000000000000000n) {
-		x >>= 64n;
-		r += 16;
+var UnsupportedChainError = class extends PanopticError {
+	name = "UnsupportedChainError";
+	constructor(chainId, cause) {
+		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
+		this.chainId = chainId;
 	}
-	if (x >= 0x100000000n) {
-		x >>= 32n;
-		r += 8;
+};
+/**
+* `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
+*/
+var InvalidSwapTokenError = class extends PanopticError {
+	name = "InvalidSwapTokenError";
+	constructor(token, currency0, currency1, cause) {
+		super(`Token ${token} is not part of the pool (currency0=${currency0}, currency1=${currency1})`, cause);
+		this.token = token;
+		this.currency0 = currency0;
+		this.currency1 = currency1;
 	}
-	if (x >= 0x10000n) {
-		x >>= 16n;
-		r += 4;
+};
+/**
+* An amount exceeds the uint128 range required by the v4 swap encoding.
+*/
+var AmountExceedsUint128Error = class extends PanopticError {
+	name = "AmountExceedsUint128Error";
+	constructor(amount, cause) {
+		super(`Amount ${amount} exceeds uint128 maximum`, cause);
+		this.amount = amount;
 	}
-	if (x >= 0x100n) {
-		x >>= 8n;
-		r += 2;
+};
+/**
+* A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
+* output (or refund the input overpay), but no `recipient` was supplied.
+*/
+var MissingSweepRecipientError = class extends PanopticError {
+	name = "MissingSweepRecipientError";
+	constructor(cause) {
+		super("A recipient is required to sweep native ETH back to the user", cause);
 	}
-	if (x >= 0x10n) r += 1;
-	return 39 - r;
-}
+};
 /**
-* Construct the bytes32 CREATE3 salt for PanopticFactoryV3.
-*
-* Mirrors:
-*   bytes32(abi.encodePacked(
-*     uint80(uint160(deployerAddress) >> 80),  // bits [159:80]  of deployer  → 10 bytes
-*     uint40(uint160(v3Pool) >> 120),           // bits [159:120] of v3Pool    →  5 bytes
-*     uint40(uint160(riskEngine) >> 120),       // bits [159:120] of riskEngine→  5 bytes
-*     salt                                      // uint96                      → 12 bytes
-*   ))
+* The V4Quoter is not available for the chain (no fallback in v1).
 */
-function computeSaltPrefixV3(deployerAddress, v3Pool, riskEngine) {
-	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
-	const pool40 = BigInt(v3Pool) >> 120n & MASK_40;
-	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
-	return deployer80 << 176n | pool40 << 136n | risk40 << 96n;
-}
-/**
-* Compute the Uniswap V4 PoolId for a PoolKey.
-*
-* Mirrors `PoolId.toId(key)` = keccak256 of the ABI-encoded PoolKey struct
-* (5 fields × 32 bytes = 160 bytes).
-*/
-function computePoolIdV4(poolKey) {
-	const fee = Number(poolKey.fee);
-	if (!Number.isInteger(fee) || fee < 0 || fee >= 2 ** 24) throw new PanopticValidationError(`fee out of uint24 range: ${fee}`);
-	const tickSpacing = Number(poolKey.tickSpacing);
-	if (!Number.isInteger(tickSpacing) || tickSpacing < -(2 ** 23) || tickSpacing > 2 ** 23 - 1) throw new PanopticValidationError(`tickSpacing out of int24 range: ${tickSpacing}`);
-	const encoded = encodeAbiParameters([
-		{ type: "address" },
-		{ type: "address" },
-		{ type: "uint24" },
-		{ type: "int24" },
-		{ type: "address" }
-	], [
-		poolKey.currency0,
-		poolKey.currency1,
-		Number(poolKey.fee),
-		Number(poolKey.tickSpacing),
-		poolKey.hooks
-	]);
-	return BigInt(keccak256(encoded));
-}
-/**
-* Construct the bytes32 CREATE3 salt for PanopticFactoryV4.
-*
-* Mirrors:
-*   bytes32(abi.encodePacked(
-*     uint80(uint160(deployerAddress) >> 80),
-*     uint40(uint256(PoolId.unwrap(key.toId())) >> 120),  // bits [159:120] of poolId
-*     uint40(uint160(riskEngine) >> 120),
-*     salt
-*   ))
-*/
-function computeSaltPrefixV4(deployerAddress, poolKey, riskEngine) {
-	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
-	const poolId40 = computePoolIdV4(poolKey) >> 120n & MASK_40;
-	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
-	return deployer80 << 176n | poolId40 << 136n | risk40 << 96n;
-}
-/** Number of iterations per chunk before yielding back to the event loop. */
-const CHUNK_SIZE = 5000n;
-/**
-* Async version of {@link minePoolAddressLocal} that yields to the event loop
-* between chunks of iterations, preventing the browser UI from freezing.
-*
-* @param params - Mining parameters (versioned: 'v3' or 'v4'). No `client` required.
-* @returns The best salt found and its rarity (number of leading hex zeros).
-*/
-async function minePoolAddressLocalAsync(params) {
-	const { factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
-	let bestSalt = salt;
-	let highestRarity = 0n;
-	const maxSalt = salt + loops;
-	const saltPrefix = params.version === "v3" ? computeSaltPrefixV3(deployerAddress, params.v3Pool, riskEngine) : computeSaltPrefixV4(deployerAddress, params.poolKey, riskEngine);
-	let currentSalt = salt;
-	while (currentSalt < maxSalt) {
-		const chunkEnd = currentSalt + CHUNK_SIZE < maxSalt ? currentSalt + CHUNK_SIZE : maxSalt;
-		let done = false;
-		for (; currentSalt < chunkEnd; currentSalt++) {
-			const newSalt = saltPrefix | currentSalt & MASK_96;
-			const addrInt = addressOfClone3(factoryAddress, newSalt);
-			const rarity = BigInt(numberOfLeadingHexZeros(addrInt));
-			if (rarity > highestRarity) {
-				highestRarity = rarity;
-				bestSalt = currentSalt;
-			}
-			if (rarity >= minTargetRarity) {
-				highestRarity = rarity;
-				bestSalt = currentSalt;
-				done = true;
-				break;
-			}
-		}
-		if (done) break;
-		await new Promise((resolve) => setTimeout(resolve, 0));
+var QuoterUnavailableError = class extends PanopticError {
+	name = "QuoterUnavailableError";
+	constructor(chainId, cause) {
+		super(`V4Quoter unavailable for chain ${chainId}`, cause);
+		this.chainId = chainId;
 	}
-	return {
-		bestSalt,
-		highestRarity
-	};
-}
+};
 
 //#endregion
-//#region src/panoptic/v2/abis/stateView.ts
+//#region src/uniswap/v3/router/encodeSwap.ts
+const UINT128_MAX$4 = (1n << 128n) - 1n;
+
+//#endregion
+//#region src/uniswap/v3/abis/quoterV2.ts
 /**
-* Minimal Uniswap V4 StateView ABI for fee growth reads.
-* Only includes functions needed by streamia history.
+* Minimal Uniswap v3 QuoterV2 ABI (`quoteExactInputSingle`).
+*
+* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
+* `simulateContract`), so it must be simulated, not read.
+* @module uniswap/v3/abis/quoterV2
 */
-const stateViewAbi = [
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getSlot0",
-		outputs: [
+const quoterV2Abi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
 			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
+				name: "tokenOut",
+				type: "address"
 			},
 			{
-				internalType: "uint24",
-				name: "protocolFee",
-				type: "uint24"
+				name: "amountIn",
+				type: "uint256"
 			},
 			{
-				internalType: "uint24",
-				name: "lpFee",
+				name: "fee",
 				type: "uint24"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getFeeGrowthGlobals",
-		outputs: [{
-			internalType: "uint256",
-			name: "feeGrowthGlobal0",
-			type: "uint256"
-		}, {
-			internalType: "uint256",
-			name: "feeGrowthGlobal1",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}, {
-			internalType: "int24",
-			name: "tick",
-			type: "int24"
-		}],
-		name: "getTickInfo",
-		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"
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
 			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getLiquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "liquidity",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
-	}
-];
+		]
+	}],
+	outputs: [
+		{
+			name: "amountOut",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}];
 
 //#endregion
-//#region src/panoptic/v2/abis/uniswapV3Pool.ts
+//#region src/uniswap/v3/addresses.ts
 /**
-* Minimal Uniswap V3 Pool ABI for fee growth reads.
-* Only includes functions needed by streamia history.
+* Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
+* after verifying against the canonical Uniswap v3 deployment listing.
 */
-const uniswapV3PoolAbi = [
-	{
-		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: [],
-		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: "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: "liquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "fee",
-		outputs: [{
-			internalType: "uint24",
-			name: "",
-			type: "uint24"
-		}],
-		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"
-	},
-	{
-		inputs: [],
-		name: "tickSpacing",
-		outputs: [{
-			internalType: "int24",
-			name: "",
-			type: "int24"
-		}],
-		stateMutability: "view",
-		type: "function"
-	}
-];
+const UNISWAP_V3_ADDRESSES = { 1: {
+	quoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+	nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+} };
+/**
+* Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+*
+* @throws {UnsupportedChainError} when the chain is not listed and overrides do
+*   not supply every required address.
+*/
+function getUniswapV3Addresses(chainId, overrides) {
+	const id = Number(chainId);
+	const base = UNISWAP_V3_ADDRESSES[id];
+	const merged = {
+		...base,
+		...overrides
+	};
+	if (!merged.quoterV2 || !merged.nonfungiblePositionManager) throw new UnsupportedChainError(BigInt(id));
+	return merged;
+}
 
 //#endregion
-//#region src/panoptic/v2/formatters/tick.ts
-const Q192$3 = 1n << 192n;
-const RAW_PRICE_PRECISION = 40n;
-function pow10(exponent) {
-	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
-	return 10n ** exponent;
+//#region src/uniswap/v3/router/quote.ts
+const BPS_DENOMINATOR$6 = 10000n;
+const UINT128_MAX$3 = (1n << 128n) - 1n;
+/**
+* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+* pool does not exist / has no liquidity) so callers can skip that pool when
+* ranking venues, rather than aborting the whole cycle.
+*/
+async function quoteV3ExactIn(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
+	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$6) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactInputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amountIn,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountOut, , , gasEstimate] = result;
+		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$6 - slippageBps) / BPS_DENOMINATOR$6;
+		return {
+			amountOut,
+			amountOutMinimum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert(err)) return null;
+		throw err;
+	}
 }
-function absBigint(value) {
-	return value < 0n ? -value : value;
+/** True only for genuine contract reverts (missing pool / no liquidity). */
+function isRevert(err) {
+	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
 }
-function trimTrailingZeros(value) {
-	const dotIndex = value.indexOf(".");
-	if (dotIndex === -1) return value;
-	let end = value.length;
-	while (end > dotIndex && value[end - 1] === "0") end -= 1;
-	if (end === dotIndex + 1) end = dotIndex;
-	return value.slice(0, end);
+
+//#endregion
+//#region src/panoptic/v2/reads/sfpm.ts
+/**
+* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
+*
+* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
+*/
+async function getUniswapV3PoolFromId(params) {
+	const { client, sfpmAddress, poolId } = params;
+	return client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
+	});
 }
-function formatRatio$3(numerator, denominator, precision) {
-	if (precision < 0n) throw new RangeError("Precision must be non-negative");
-	const sign = numerator < 0n ? "-" : "";
-	const absNumerator = numerator < 0n ? -numerator : numerator;
-	const scale = pow10(precision);
-	const scaled = (absNumerator * scale + denominator / 2n) / denominator;
-	const integerPart = scaled / scale;
-	const fractionalPart = scaled % scale;
-	if (precision === 0n) return `${sign}${integerPart}`;
-	return `${sign}${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
-}
-function parseDecimalToFraction(value) {
-	const trimmed = value.trim();
-	if (trimmed.length === 0) throw new Error("Price must be a number");
-	const isNegative = trimmed.startsWith("-");
-	const unsigned = isNegative || trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
-	const [basePart, exponentPart] = unsigned.toLowerCase().split("e");
-	const [integerStr, fractionalStr = ""] = basePart.split(".");
-	if (integerStr === "" && fractionalStr === "") throw new Error("Price must be a number");
-	const integerDigits = integerStr === "" ? "0" : integerStr;
-	const digits = `${integerDigits}${fractionalStr}`;
-	let numerator = BigInt(digits === "" ? "0" : digits);
-	let denominator = pow10(BigInt(fractionalStr.length));
-	if (exponentPart !== void 0 && exponentPart !== "") {
-		const exponent = BigInt(exponentPart);
-		if (exponent > 0n) numerator *= pow10(exponent);
-		else if (exponent < 0n) denominator *= pow10(-exponent);
-	}
-	if (isNegative) numerator = -numerator;
+/**
+* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
+*
+* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
+*/
+async function getUniswapV4PoolKeyFromId(params) {
+	const { client, sfpmAddress, poolId } = params;
+	const raw = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV4Abi,
+		functionName: "getUniswapV4PoolKeyFromId",
+		args: [poolId]
+	});
 	return {
-		numerator,
-		denominator
+		currency0: raw.currency0,
+		currency1: raw.currency1,
+		fee: BigInt(raw.fee),
+		tickSpacing: BigInt(raw.tickSpacing),
+		hooks: raw.hooks
 	};
 }
-function compareRatios(leftNumerator, leftDenominator, rightNumerator, rightDenominator) {
-	const left = leftNumerator * rightDenominator;
-	const right = rightNumerator * leftDenominator;
-	if (left === right) return 0;
-	return left < right ? -1 : 1;
-}
-function tickToSqrtPriceX96(tick) {
-	if (tick < MIN_TICK || tick > MAX_TICK) throw new RangeError("Tick out of bounds");
-	const absTick = tick < 0n ? -tick : tick;
-	let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
-	if ((absTick & 0x2n) !== 0n) ratio = ratio * 0xfff97272373d413259a46990580e213an >> 128n;
-	if ((absTick & 0x4n) !== 0n) ratio = ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn >> 128n;
-	if ((absTick & 0x8n) !== 0n) ratio = ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n >> 128n;
-	if ((absTick & 0x10n) !== 0n) ratio = ratio * 0xffcb9843d60f6159c9db58835c926644n >> 128n;
-	if ((absTick & 0x20n) !== 0n) ratio = ratio * 0xff973b41fa98c081472e6896dfb254c0n >> 128n;
-	if ((absTick & 0x40n) !== 0n) ratio = ratio * 0xff2ea16466c96a3843ec78b326b52861n >> 128n;
-	if ((absTick & 0x80n) !== 0n) ratio = ratio * 0xfe5dee046a99a2a811c461f1969c3053n >> 128n;
-	if ((absTick & 0x100n) !== 0n) ratio = ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n >> 128n;
-	if ((absTick & 0x200n) !== 0n) ratio = ratio * 0xf987a7253ac413176f2b074cf7815e54n >> 128n;
-	if ((absTick & 0x400n) !== 0n) ratio = ratio * 0xf3392b0822b70005940c7a398e4b70f3n >> 128n;
-	if ((absTick & 0x800n) !== 0n) ratio = ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n >> 128n;
-	if ((absTick & 0x1000n) !== 0n) ratio = ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n >> 128n;
-	if ((absTick & 0x2000n) !== 0n) ratio = ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n >> 128n;
-	if ((absTick & 0x4000n) !== 0n) ratio = ratio * 0x70d869a156d2a1b890bb3df62baf32f7n >> 128n;
-	if ((absTick & 0x8000n) !== 0n) ratio = ratio * 0x31be135f97d08fd981231505542fcfa6n >> 128n;
-	if ((absTick & 0x10000n) !== 0n) ratio = ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n >> 128n;
-	if ((absTick & 0x20000n) !== 0n) ratio = ratio * 0x5d6af8dedb81196699c329225ee604n >> 128n;
-	if ((absTick & 0x40000n) !== 0n) ratio = ratio * 0x2216e584f5fa1ea926041bedfe98n >> 128n;
-	if ((absTick & 0x80000n) !== 0n) ratio = ratio * 0x48a170391f7dc42444e8fa2n >> 128n;
-	if (tick > 0n) ratio = ((1n << 256n) - 1n) / ratio;
-	const remainderMask = (1n << 32n) - 1n;
-	const sqrtPriceX96 = (ratio >> 32n) + ((ratio & remainderMask) === 0n ? 0n : 1n);
-	return sqrtPriceX96;
-}
-const MIN_SQRT_PRICE_X96 = tickToSqrtPriceX96(MIN_TICK);
-const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
-function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
+/**
+* Get the enforced tick limits for a pool from the SFPM.
+*
+* @param params - The parameters
+* @returns The min and max enforced ticks
+*/
+async function getEnforcedTickLimits(params) {
+	const { client, sfpmAddress, poolId } = params;
+	const [minTick, maxTick] = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV4Abi,
+		functionName: "getEnforcedTickLimits",
+		args: [poolId]
+	});
 	return {
-		numerator: sqrtPriceX96 * sqrtPriceX96,
-		denominator: Q192$3
+		minEnforcedTick: minTick,
+		maxEnforcedTick: maxTick
 	};
 }
-function getRawPriceRatio(tick) {
-	return getPriceRatioFromSqrtPriceX96(tickToSqrtPriceX96(tick));
-}
-function adjustRatioForDecimals(numerator, denominator, decimals0, decimals1) {
-	const diff = decimals0 - decimals1;
-	if (diff === 0n) return {
-		numerator,
-		denominator
-	};
-	if (diff > 0n) return {
-		numerator: numerator * pow10(diff),
-		denominator
+/**
+* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
+*
+* Uses multicall for efficiency. Returns one result per input chunk,
+* along with block metadata for freshness tracking.
+*/
+async function getChunkLiquidities(params) {
+	const { client, sfpmAddress, poolKeyBytes, chunks } = params;
+	if (chunks.length > MAX_TRACKED_CHUNKS) throw new ChunkLimitError(BigInt(chunks.length), 0n);
+	const _meta = params._meta ?? await getBlockMeta({ client });
+	if (chunks.length === 0) return {
+		results: [],
+		_meta
 	};
+	const multicallResults = await client.multicall({
+		contracts: chunks.map((chunk) => ({
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV4Abi,
+			functionName: "getAccountLiquidity",
+			args: [
+				poolKeyBytes,
+				chunk.owner,
+				chunk.tokenType,
+				Number(chunk.tickLower),
+				Number(chunk.tickUpper)
+			]
+		})),
+		allowFailure: true
+	});
+	const results = multicallResults.map((result) => {
+		if (result.status === "failure") return {
+			netLiquidity: 0n,
+			removedLiquidity: 0n,
+			totalLiquidity: 0n,
+			shortLiquidity: 0n,
+			longLiquidity: 0n
+		};
+		const packed = result.result;
+		const netLiquidity = packed & (1n << 128n) - 1n;
+		const removedLiquidity = packed >> 128n;
+		const totalLiquidity = netLiquidity + removedLiquidity;
+		return {
+			netLiquidity,
+			removedLiquidity,
+			totalLiquidity,
+			shortLiquidity: totalLiquidity,
+			longLiquidity: removedLiquidity
+		};
+	});
 	return {
-		numerator,
-		denominator: denominator * pow10(-diff)
+		results,
+		_meta
 	};
 }
+
+//#endregion
+//#region src/panoptic/v2/reads/factory.ts
 /**
-* Convert a tick to a raw price string (no decimal adjustment).
-* Uses the formula: price = 1.0001^tick
-*
-* This returns the raw price ratio, not adjusted for token decimals.
-* A fixed internal precision is used and trailing zeros are trimmed.
-*
-* @param tick - The tick value
-* @returns Price string
-*
-* @example
-* ```typescript
-* tickToPrice(0n)       // "1"
-* tickToPrice(1000n)    // "1.105..." (approximately)
-* tickToPrice(-1000n)   // "0.904..." (approximately)
-* tickToPrice(200000n)  // Very large number
-* ```
+* Get the token URI from a PanopticFactory NFT.
 */
-function tickToPrice(tick) {
-	const { numerator, denominator } = getRawPriceRatio(tick);
-	const price = formatRatio$3(numerator, denominator, RAW_PRICE_PRECISION);
-	return trimTrailingZeros(price);
+async function getFactoryTokenURI(params) {
+	const { client, factoryAddress, version, tokenId } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "tokenURI",
+		args: [tokenId]
+	});
 }
 /**
-* Convert a tick to a human-readable price with decimal scaling.
-* Uses the formula: price = 1.0001^tick * 10^(decimals0-decimals1)
-*
-* This adjusts for the different decimals of the two tokens in the pair.
-*
-* @param tick - The tick value
-* @param decimals0 - Decimals of token0
-* @param decimals1 - Decimals of token1
-* @param precision - Number of decimal places to display
-* @returns Formatted price string
-*
-* @example
-* ```typescript
-* // WETH/USDC pool (18 decimals / 6 decimals)
-* // At tick ~200000, price is roughly $2000 per ETH
-* tickToPriceDecimalScaled(200000n, 18n, 6n, 2n) // "2000.00" (approximately)
-*
-* // For token1/token0 price, swap the decimals
-* tickToPriceDecimalScaled(200000n, 6n, 18n, 6n) // "0.000500" (approximately)
-* ```
+* Get the owner of a PanopticFactory NFT.
 */
-function tickToPriceDecimalScaled(tick, decimals0, decimals1, precision) {
-	const rawRatio = getRawPriceRatio(tick);
-	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
-	return formatRatio$3(numerator, denominator, precision);
+async function getFactoryOwnerOf(params) {
+	const { client, factoryAddress, version, tokenId } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "ownerOf",
+		args: [tokenId]
+	});
 }
 /**
-* Convert a sqrtPriceX96 to a human-readable price with decimal scaling.
-*
-* Uses the formula: price = (sqrtPriceX96^2 / 2^192) * 10^(decimals0-decimals1)
-*
-* @param sqrtPriceX96 - The sqrt price in Q64.96 format
-* @param decimals0 - Decimals of token0
-* @param decimals1 - Decimals of token1
-* @param precision - Number of decimal places to display
-* @returns Formatted price string
-*
-* @example
-* ```typescript
-* sqrtPriceX96ToPriceDecimalScaled(2n ** 96n, 18n, 18n, 2n) // "1.00"
-* ```
+* Construct NFT metadata for a pool via the factory contract.
 */
-function sqrtPriceX96ToPriceDecimalScaled(sqrtPriceX96, decimals0, decimals1, precision) {
-	const rawRatio = getPriceRatioFromSqrtPriceX96(sqrtPriceX96);
-	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
-	return formatRatio$3(numerator, denominator, precision);
-}
-/**
-* Convert a price to a tick value.
-*
-* @param price - The price string
-* @param decimals0 - Decimals of token0
-* @param decimals1 - Decimals of token1
-* @returns The tick value (rounded to nearest integer)
-*
-* @example
-* ```typescript
-* // WETH/USDC: What tick for $2000 per ETH?
-* priceToTick("2000", 18n, 6n) // ~200000n
-*
-* // Inverse: What tick for 0.0005 ETH per USDC?
-* priceToTick("0.0005", 6n, 18n) // ~200000n
-* ```
-*/
-function priceToTick(price, decimals0, decimals1) {
-	const parsed = parseDecimalToFraction(price);
-	if (parsed.numerator <= 0n) throw new Error("Price must be positive");
-	let targetNumerator = parsed.numerator;
-	let targetDenominator = parsed.denominator;
-	const diff = decimals0 - decimals1;
-	if (diff > 0n) targetDenominator *= pow10(diff);
-	else if (diff < 0n) targetNumerator *= pow10(-diff);
-	let low = MIN_TICK;
-	let high = MAX_TICK;
-	while (low <= high) {
-		const mid = (low + high) / 2n;
-		const { numerator, denominator } = getRawPriceRatio(mid);
-		const cmp = compareRatios(numerator, denominator, targetNumerator, targetDenominator);
-		if (cmp === 0) return mid;
-		if (cmp < 0) low = mid + 1n;
-		else high = mid - 1n;
-	}
-	const floorTick = high;
-	const ceilTick = low;
-	if (floorTick < MIN_TICK) return MIN_TICK;
-	if (ceilTick > MAX_TICK) return MAX_TICK;
-	const floorRatio = getRawPriceRatio(floorTick);
-	const ceilRatio = getRawPriceRatio(ceilTick);
-	const floorDiffNumerator = absBigint(targetNumerator * floorRatio.denominator - floorRatio.numerator * targetDenominator);
-	const ceilDiffNumerator = absBigint(targetNumerator * ceilRatio.denominator - ceilRatio.numerator * targetDenominator);
-	const floorDiffDenominator = targetDenominator * floorRatio.denominator;
-	const ceilDiffDenominator = targetDenominator * ceilRatio.denominator;
-	return floorDiffNumerator * ceilDiffDenominator <= ceilDiffNumerator * floorDiffDenominator ? floorTick : ceilTick;
-}
-/**
-* Convert a sqrtPriceX96 value to the nearest tick.
-*
-* @param sqrtPriceX96 - The sqrt price in Q64.96 format
-* @returns The tick value (rounded to nearest integer)
-*
-* @example
-* ```typescript
-* const tick = sqrtPriceX96ToTick(2n ** 96n) // 0n
-* ```
-*/
-function sqrtPriceX96ToTick(sqrtPriceX96) {
-	if (sqrtPriceX96 <= 0n) throw new Error("Sqrt price must be positive");
-	if (sqrtPriceX96 < MIN_SQRT_PRICE_X96 || sqrtPriceX96 > MAX_SQRT_PRICE_X96) throw new RangeError("Sqrt price out of bounds");
-	let low = MIN_TICK;
-	let high = MAX_TICK;
-	while (low <= high) {
-		const mid = (low + high) / 2n;
-		const midSqrt = tickToSqrtPriceX96(mid);
-		if (midSqrt === sqrtPriceX96) return mid;
-		if (midSqrt < sqrtPriceX96) low = mid + 1n;
-		else high = mid - 1n;
-	}
-	const floorTick = high;
-	const ceilTick = low;
-	if (floorTick < MIN_TICK) return MIN_TICK;
-	if (ceilTick > MAX_TICK) return MAX_TICK;
-	const floorSqrt = tickToSqrtPriceX96(floorTick);
-	const ceilSqrt = tickToSqrtPriceX96(ceilTick);
-	const floorDiff = absBigint(sqrtPriceX96 - floorSqrt);
-	const ceilDiff = absBigint(ceilSqrt - sqrtPriceX96);
-	return floorDiff <= ceilDiff ? floorTick : ceilTick;
+async function getFactoryConstructMetadata(params) {
+	const { client, factoryAddress, version, panopticPoolAddress, symbol0, symbol1, fee } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "constructMetadata",
+		args: [
+			panopticPoolAddress,
+			symbol0,
+			symbol1,
+			fee
+		]
+	});
 }
 /**
-* Format a tick value for display.
-*
-* @param tick - The tick value
-* @returns Formatted tick string
-*
-* @example
-* ```typescript
-* formatTick(200000n)  // "200000"
-* formatTick(-50000n)  // "-50000"
-* ```
+* Get the PanopticPool address for a given pool and risk engine.
 */
-function formatTick(tick) {
-	return tick.toString();
+async function getPanopticPoolAddress(params) {
+	const { client, factoryAddress, riskEngine } = params;
+	if (params.version === "v3") return client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV3Abi,
+		functionName: "getPanopticPool",
+		args: [params.univ3pool, riskEngine]
+	});
+	return client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "getPanopticPool",
+		args: [{
+			currency0: params.poolKey.currency0,
+			currency1: params.poolKey.currency1,
+			fee: Number(params.poolKey.fee),
+			tickSpacing: Number(params.poolKey.tickSpacing),
+			hooks: params.poolKey.hooks
+		}, riskEngine]
+	});
 }
 /**
-* Get the price at a specific tick, returning both token0/token1 and token1/token0 prices.
-*
-* @param tick - The tick value
-* @param decimals0 - Decimals of token0
-* @param decimals1 - Decimals of token1
-* @param precision - Number of decimal places to display
-* @returns Object with both price directions
-*
-* @example
-* ```typescript
-* const prices = getPricesAtTick(200000n, 18n, 6n, 2n)
-* // prices.token0PerToken1 = "0.00" (very small)
-* // prices.token1PerToken0 = "2000.00" (USDC per ETH)
-* ```
+* Mine for an optimal pool address salt with high rarity.
 */
-function getPricesAtTick(tick, decimals0, decimals1, precision) {
-	const rawRatio = getRawPriceRatio(tick);
-	const adjustedRatio = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+async function minePoolAddress(params) {
+	const { client, factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
+	let result;
+	if (params.version === "v3") result = await client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV3Abi,
+		functionName: "minePoolAddress",
+		args: [
+			deployerAddress,
+			params.v3Pool,
+			riskEngine,
+			salt,
+			loops,
+			minTargetRarity
+		]
+	});
+	else result = await client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "minePoolAddress",
+		args: [
+			deployerAddress,
+			{
+				currency0: params.poolKey.currency0,
+				currency1: params.poolKey.currency1,
+				fee: Number(params.poolKey.fee),
+				tickSpacing: Number(params.poolKey.tickSpacing),
+				hooks: params.poolKey.hooks
+			},
+			riskEngine,
+			salt,
+			loops,
+			minTargetRarity
+		]
+	});
 	return {
-		token0PerToken1: formatRatio$3(adjustedRatio.denominator, adjustedRatio.numerator, precision),
-		token1PerToken0: formatRatio$3(adjustedRatio.numerator, adjustedRatio.denominator, precision)
+		bestSalt: BigInt(result[0]),
+		highestRarity: result[1]
 	};
 }
 /**
-* Format a tick range for display.
-*
-* @param tickLower - Lower tick
-* @param tickUpper - Upper tick
-* @returns Formatted tick range string
+* Simulate a pool deployment to get the predicted pool address.
 *
-* @example
-* ```typescript
-* formatTickRange(-50000n, 200000n) // "-50000 - 200000"
-* ```
+* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
+* without actually executing the transaction.
 */
-function formatTickRange(tickLower, tickUpper) {
-	return `${tickLower} - ${tickUpper}`;
+async function simulateDeployNewPool(params) {
+	const { client, factoryAddress, account, riskEngine, salt } = params;
+	if (params.version === "v3") {
+		const { result: result$1 } = await client.simulateContract({
+			address: factoryAddress,
+			abi: panopticFactoryV3Abi,
+			functionName: "deployNewPool",
+			args: [
+				params.token0,
+				params.token1,
+				Number(params.fee),
+				riskEngine,
+				salt
+			],
+			account
+		});
+		return result$1;
+	}
+	const { result } = await client.simulateContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "deployNewPool",
+		args: [
+			{
+				currency0: params.poolKey.currency0,
+				currency1: params.poolKey.currency1,
+				fee: Number(params.poolKey.fee),
+				tickSpacing: Number(params.poolKey.tickSpacing),
+				hooks: params.poolKey.hooks
+			},
+			riskEngine,
+			salt
+		],
+		account
+	});
+	return result;
 }
 /**
-* Format a price range for display.
-*
-* @param tickLower - Lower tick
-* @param tickUpper - Upper tick
-* @param decimals0 - Decimals of token0
-* @param decimals1 - Decimals of token1
-* @param precision - Number of decimal places to display
-* @returns Formatted price range string
+* Resolve an SFPM poolId to its PanopticPool address.
 *
-* @example
-* ```typescript
-* formatPriceRange(0n, 0n, 18n, 18n, 2n) // "1.00 - 1.00"
-* ```
+* Chains two on-chain lookups:
+* 1. SFPM: poolId → Uniswap pool address (V3) or pool key (V4)
+* 2. Factory: Uniswap pool + riskEngine → PanopticPool address
 */
-function formatPriceRange(tickLower, tickUpper, decimals0, decimals1, precision) {
-	const lower = tickToPriceDecimalScaled(tickLower, decimals0, decimals1, precision);
-	const upper = tickToPriceDecimalScaled(tickUpper, decimals0, decimals1, precision);
-	return `${lower} - ${upper}`;
-}
-/**
-* Calculate the tick spacing for a given fee tier.
-*
-* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
-* @returns Tick spacing
-*
-* @example
-* ```typescript
-* getTickSpacing(100n)  // 1n (0.01% fee tier)
-* getTickSpacing(500n)  // 10n (0.05% fee tier)
-* getTickSpacing(3000n) // 60n (0.30% fee tier)
-* getTickSpacing(10000n) // 200n (1.00% fee tier)
-* ```
+async function getPanopticPoolFromPoolId(params) {
+	const { client, sfpmAddress, factoryAddress, riskEngine, poolId, version } = params;
+	if (version === "v3") {
+		const univ3pool = await getUniswapV3PoolFromId({
+			client,
+			sfpmAddress,
+			poolId
+		});
+		return getPanopticPoolAddress({
+			version: "v3",
+			client,
+			factoryAddress,
+			univ3pool,
+			riskEngine
+		});
+	}
+	const poolKey = await getUniswapV4PoolKeyFromId({
+		client,
+		sfpmAddress,
+		poolId
+	});
+	return getPanopticPoolAddress({
+		version: "v4",
+		client,
+		factoryAddress,
+		poolKey,
+		riskEngine
+	});
+}
+/**
+* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
+*
+* Tries both V3 and V4 lookups in parallel. The factory returns `address(0)` for
+* non-existent pools, so the non-zero result identifies the correct version.
+*
+* At least one of `v3` or `v4` must be provided.
+*
+* @throws {PanopticValidationError} If no version config is provided or neither resolves.
 */
-function getTickSpacing(feeBps) {
-	switch (feeBps) {
-		case 100n: return 1n;
-		case 500n: return 10n;
-		case 3000n: return 60n;
-		case 10000n: return 200n;
-		default: {
-			const spacing = feeBps / 50n;
-			return spacing > 1n ? spacing : 1n;
+async function resolvePanopticPoolFromPoolId(params) {
+	const { client, poolId, riskEngine, v3, v4 } = params;
+	if (!v3 && !v4) throw new Error("At least one of v3 or v4 must be provided");
+	const isNotFoundError = (err) => {
+		if (typeof err === "object" && err !== null && "name" in err) {
+			const name = err.name;
+			return name === "ContractFunctionExecutionError" || name === "ContractFunctionRevertedError";
 		}
+		return false;
+	};
+	const results = await Promise.all([v3 ? getPanopticPoolFromPoolId({
+		version: "v3",
+		client,
+		sfpmAddress: v3.sfpmAddress,
+		factoryAddress: v3.factoryAddress,
+		riskEngine,
+		poolId
+	}).catch((err) => {
+		if (isNotFoundError(err)) return zeroAddress;
+		throw err;
+	}) : Promise.resolve(zeroAddress), v4 ? getPanopticPoolFromPoolId({
+		version: "v4",
+		client,
+		sfpmAddress: v4.sfpmAddress,
+		factoryAddress: v4.factoryAddress,
+		riskEngine,
+		poolId
+	}).catch((err) => {
+		if (isNotFoundError(err)) return zeroAddress;
+		throw err;
+	}) : Promise.resolve(zeroAddress)]);
+	const [v3Result, v4Result] = results;
+	if (v3Result !== zeroAddress) return {
+		panopticPoolAddress: v3Result,
+		version: "v3"
+	};
+	if (v4Result !== zeroAddress) return {
+		panopticPoolAddress: v4Result,
+		version: "v4"
+	};
+	throw new Error(`No PanopticPool found for poolId ${poolId}`);
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
+/**
+* keccak256 of the CREATE3 proxy initcode used by ClonesWithImmutableArgs.
+* Source: packages/panoptic-v2-core/lib/clones-with-immutable-args/src/ClonesWithImmutableArgs.sol
+*/
+const CREATE3_PROXY_BYTECODE_HASH = "0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f";
+const MASK_80 = (1n << 80n) - 1n;
+const MASK_40 = (1n << 40n) - 1n;
+const MASK_96 = (1n << 96n) - 1n;
+/** Encode a BigInt as a big-endian fixed-length byte array. */
+function bigintToBytes(value, byteLength) {
+	const bytes = new Uint8Array(byteLength);
+	let v = value;
+	for (let i = byteLength - 1; i >= 0; i--) {
+		bytes[i] = Number(v & 0xffn);
+		v >>= 8n;
+	}
+	return bytes;
+}
+/** Parse a 0x-prefixed address into 20 bytes. */
+function addressToBytes(addr) {
+	const hex = addr.slice(2).padStart(40, "0");
+	const bytes = new Uint8Array(20);
+	for (let i = 0; i < 20; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/** Parse a 0x-prefixed 32-byte hex string into bytes. */
+function hex32ToBytes(hex) {
+	const h = hex.slice(2).padStart(64, "0");
+	const bytes = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Compute the CREATE3 deployed address for a given factory and packed salt.
+*
+* Mirrors `ClonesWithImmutableArgs.addressOfClone3(salt)` (with `address(this)` = factory):
+*   proxy    = CREATE2(factory, salt, PROXY_BYTECODE_HASH)
+*   deployed = CREATE1(proxy, nonce=1)
+*
+* Returns the deployed address as a uint160 BigInt.
+*/
+function addressOfClone3(factory, salt) {
+	const saltBytes = bigintToBytes(salt, 32);
+	const create2Input = new Uint8Array(85);
+	create2Input[0] = 255;
+	create2Input.set(addressToBytes(factory), 1);
+	create2Input.set(saltBytes, 21);
+	create2Input.set(hex32ToBytes(CREATE3_PROXY_BYTECODE_HASH), 53);
+	const proxyHash = keccak256(create2Input, "bytes");
+	const proxyAddress = proxyHash.slice(12);
+	const create1Input = new Uint8Array(23);
+	create1Input[0] = 214;
+	create1Input[1] = 148;
+	create1Input.set(proxyAddress, 2);
+	create1Input[22] = 1;
+	const deployedHash = keccak256(create1Input, "bytes");
+	let addr = 0n;
+	for (let i = 12; i < 32; i++) addr = addr << 8n | BigInt(deployedHash[i]);
+	return addr;
+}
+/**
+* Count leading hex-zero characters in a 160-bit address value.
+*
+* Mirrors `PanopticMath.numberOfLeadingHexZeros(addr)`.
+* Returns 40 for the zero address.
+*/
+function numberOfLeadingHexZeros(addrInt) {
+	if (addrInt === 0n) return 40;
+	let x = addrInt;
+	let r = 0;
+	if (x >= 0x100000000000000000000000000000000n) {
+		x >>= 128n;
+		r += 32;
+	}
+	if (x >= 0x10000000000000000n) {
+		x >>= 64n;
+		r += 16;
+	}
+	if (x >= 0x100000000n) {
+		x >>= 32n;
+		r += 8;
+	}
+	if (x >= 0x10000n) {
+		x >>= 16n;
+		r += 4;
+	}
+	if (x >= 0x100n) {
+		x >>= 8n;
+		r += 2;
+	}
+	if (x >= 0x10n) r += 1;
+	return 39 - r;
+}
+/**
+* Construct the bytes32 CREATE3 salt for PanopticFactoryV3.
+*
+* Mirrors:
+*   bytes32(abi.encodePacked(
+*     uint80(uint160(deployerAddress) >> 80),  // bits [159:80]  of deployer  → 10 bytes
+*     uint40(uint160(v3Pool) >> 120),           // bits [159:120] of v3Pool    →  5 bytes
+*     uint40(uint160(riskEngine) >> 120),       // bits [159:120] of riskEngine→  5 bytes
+*     salt                                      // uint96                      → 12 bytes
+*   ))
+*/
+function computeSaltPrefixV3(deployerAddress, v3Pool, riskEngine) {
+	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
+	const pool40 = BigInt(v3Pool) >> 120n & MASK_40;
+	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
+	return deployer80 << 176n | pool40 << 136n | risk40 << 96n;
+}
+/**
+* Compute the Uniswap V4 PoolId for a PoolKey.
+*
+* Mirrors `PoolId.toId(key)` = keccak256 of the ABI-encoded PoolKey struct
+* (5 fields × 32 bytes = 160 bytes).
+*/
+function computePoolIdV4(poolKey) {
+	const fee = Number(poolKey.fee);
+	if (!Number.isInteger(fee) || fee < 0 || fee >= 2 ** 24) throw new PanopticValidationError(`fee out of uint24 range: ${fee}`);
+	const tickSpacing = Number(poolKey.tickSpacing);
+	if (!Number.isInteger(tickSpacing) || tickSpacing < -(2 ** 23) || tickSpacing > 2 ** 23 - 1) throw new PanopticValidationError(`tickSpacing out of int24 range: ${tickSpacing}`);
+	const encoded = encodeAbiParameters([
+		{ type: "address" },
+		{ type: "address" },
+		{ type: "uint24" },
+		{ type: "int24" },
+		{ type: "address" }
+	], [
+		poolKey.currency0,
+		poolKey.currency1,
+		Number(poolKey.fee),
+		Number(poolKey.tickSpacing),
+		poolKey.hooks
+	]);
+	return BigInt(keccak256(encoded));
+}
+/**
+* Construct the bytes32 CREATE3 salt for PanopticFactoryV4.
+*
+* Mirrors:
+*   bytes32(abi.encodePacked(
+*     uint80(uint160(deployerAddress) >> 80),
+*     uint40(uint256(PoolId.unwrap(key.toId())) >> 120),  // bits [159:120] of poolId
+*     uint40(uint160(riskEngine) >> 120),
+*     salt
+*   ))
+*/
+function computeSaltPrefixV4(deployerAddress, poolKey, riskEngine) {
+	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
+	const poolId40 = computePoolIdV4(poolKey) >> 120n & MASK_40;
+	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
+	return deployer80 << 176n | poolId40 << 136n | risk40 << 96n;
+}
+/** Number of iterations per chunk before yielding back to the event loop. */
+const CHUNK_SIZE = 5000n;
+/**
+* Async version of {@link minePoolAddressLocal} that yields to the event loop
+* between chunks of iterations, preventing the browser UI from freezing.
+*
+* @param params - Mining parameters (versioned: 'v3' or 'v4'). No `client` required.
+* @returns The best salt found and its rarity (number of leading hex zeros).
+*/
+async function minePoolAddressLocalAsync(params) {
+	const { factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
+	let bestSalt = salt;
+	let highestRarity = 0n;
+	const maxSalt = salt + loops;
+	const saltPrefix = params.version === "v3" ? computeSaltPrefixV3(deployerAddress, params.v3Pool, riskEngine) : computeSaltPrefixV4(deployerAddress, params.poolKey, riskEngine);
+	let currentSalt = salt;
+	while (currentSalt < maxSalt) {
+		const chunkEnd = currentSalt + CHUNK_SIZE < maxSalt ? currentSalt + CHUNK_SIZE : maxSalt;
+		let done = false;
+		for (; currentSalt < chunkEnd; currentSalt++) {
+			const newSalt = saltPrefix | currentSalt & MASK_96;
+			const addrInt = addressOfClone3(factoryAddress, newSalt);
+			const rarity = BigInt(numberOfLeadingHexZeros(addrInt));
+			if (rarity > highestRarity) {
+				highestRarity = rarity;
+				bestSalt = currentSalt;
+			}
+			if (rarity >= minTargetRarity) {
+				highestRarity = rarity;
+				bestSalt = currentSalt;
+				done = true;
+				break;
+			}
+		}
+		if (done) break;
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	}
+	return {
+		bestSalt,
+		highestRarity
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/abis/stateView.ts
+/**
+* Minimal Uniswap V4 StateView ABI for fee growth reads.
+* Only includes functions needed by streamia history.
+*/
+const stateViewAbi = [
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getSlot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint24",
+				name: "protocolFee",
+				type: "uint24"
+			},
+			{
+				internalType: "uint24",
+				name: "lpFee",
+				type: "uint24"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getFeeGrowthGlobals",
+		outputs: [{
+			internalType: "uint256",
+			name: "feeGrowthGlobal0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "feeGrowthGlobal1",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}, {
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		}],
+		name: "getTickInfo",
+		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"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getLiquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "liquidity",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/abis/uniswapV3Pool.ts
+/**
+* Minimal Uniswap V3 Pool ABI for fee growth reads.
+* Only includes functions needed by streamia history.
+*/
+const uniswapV3PoolAbi = [
+	{
+		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: [],
+		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: "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: "liquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "fee",
+		outputs: [{
+			internalType: "uint24",
+			name: "",
+			type: "uint24"
+		}],
+		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"
+	},
+	{
+		inputs: [],
+		name: "tickSpacing",
+		outputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		stateMutability: "view",
+		type: "function"
 	}
-}
-/**
-* Round a tick to the nearest valid tick for a given tick spacing.
-*
-* @param tick - The tick to round
-* @param tickSpacing - The tick spacing
-* @returns Rounded tick
-*
-* @example
-* ```typescript
-* roundToTickSpacing(12345n, 10n) // 12340n
-* roundToTickSpacing(12345n, 60n) // 12360n
-* roundToTickSpacing(-12345n, 10n) // -12350n
-* ```
-*/
-function roundToTickSpacing(tick, tickSpacing) {
-	const remainder = tick % tickSpacing;
-	if (remainder === 0n) return tick;
-	if (tick >= 0n) return remainder >= tickSpacing / 2n ? tick + (tickSpacing - remainder) : tick - remainder;
-	const absRemainder = -remainder;
-	return absRemainder >= tickSpacing / 2n ? tick - (tickSpacing - absRemainder) : tick + absRemainder;
-}
-/**
-* Compute slippage-bounded tick limits around the current tick.
-*
-* 1 tick ≈ 1 basis point (0.01 %) of price change, so a `toleranceBps`
-* of 500 allows roughly 5 % price movement.  The result is clamped to
-* the protocol's `[MIN_TICK, MAX_TICK]` range.
-*
-* Useful for setting `tickLimitLow` / `tickLimitHigh` on `openPosition`
-* and `closePosition` to protect against MEV sandwiches and volatile
-* tick moves.
-*
-* @param currentTick - The current pool tick (must be within [MIN_TICK, MAX_TICK]).
-* @param toleranceBps - Slippage tolerance in basis points (≈ ticks). Must be non-negative.
-* @returns Clamped `{ low, high }` tick limits.
-* @throws {RangeError} If `toleranceBps` is negative or `currentTick` is out of bounds.
-*
-* @example
-* ```typescript
-* const { low, high } = tickLimits(200_000n, 500n)
-* // low  = 199_500n
-* // high = 200_500n
-*
-* await openPosition({ ..., tickLimitLow: low, tickLimitHigh: high })
-* ```
-*/
-function tickLimits(currentTick, toleranceBps) {
-	if (toleranceBps < 0n) throw new RangeError(`toleranceBps must be non-negative, got ${toleranceBps}`);
-	if (currentTick < MIN_TICK || currentTick > MAX_TICK) throw new RangeError(`currentTick ${currentTick} is out of bounds [${MIN_TICK}, ${MAX_TICK}]`);
-	const rawLow = currentTick - toleranceBps;
-	const rawHigh = currentTick + toleranceBps;
-	const low = rawLow < MIN_TICK ? MIN_TICK : rawLow;
-	const high = rawHigh > MAX_TICK ? MAX_TICK : rawHigh;
-	if (low > high) throw new RangeError(`Computed tick limits are inverted: low ${low} > high ${high} (currentTick=${currentTick}, toleranceBps=${toleranceBps})`);
-	return {
-		low,
-		high
-	};
-}
+];
 
 //#endregion
 //#region src/panoptic/v2/reads/mintBuffer.ts
@@ -14789,7 +14948,7 @@ async function readBlockAndAggregate({ client, calls, blockNumber }) {
 
 //#endregion
 //#region src/panoptic/v2/reads/checks.ts
-const FP96$1 = 1n << 96n;
+const FP96$2 = 1n << 96n;
 const Q128$4 = 1n << 128n;
 function convert0to1$3(amount, sqrtPriceX96) {
 	if (sqrtPriceX96 < Q128$4) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
@@ -14940,7 +15099,7 @@ async function isLiquidatable(params) {
 	const requiredMargin1 = required1Native + convert0to1$3(required0Native, sqrtPriceX96);
 	const marginShortfall0 = requiredMargin0 - currentMargin0;
 	const marginShortfall1 = requiredMargin1 - currentMargin1;
-	const denominatedInToken = sqrtPriceX96 < FP96$1 ? 0n : 1n;
+	const denominatedInToken = sqrtPriceX96 < FP96$2 ? 0n : 1n;
 	const isLiquidatableResult = denominatedInToken === 0n ? marginShortfall0 > 0n : marginShortfall1 > 0n;
 	return {
 		isLiquidatable: isLiquidatableResult,
@@ -16954,7 +17113,7 @@ async function simulateDispatch(params) {
 
 //#endregion
 //#region src/panoptic/v2/simulations/tokenShortfallRecovery.ts
-const BPS_DENOMINATOR$4 = 10000n;
+const BPS_DENOMINATOR$5 = 10000n;
 const MAX_RECOVERY_QUOTE_ATTEMPTS = 8;
 /**
 * Wrap a dispatch with a temporary credit leg that sources the shortfall.
@@ -17004,7 +17163,7 @@ function getNotEnoughTokensError(error) {
 }
 function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
-	return (estimatedAmountIn * (BPS_DENOMINATOR$4 + slippageBps) + BPS_DENOMINATOR$4 - 1n) / BPS_DENOMINATOR$4;
+	return (estimatedAmountIn * (BPS_DENOMINATOR$5 + slippageBps) + BPS_DENOMINATOR$5 - 1n) / BPS_DENOMINATOR$5;
 }
 function ceilDiv(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
@@ -17032,10 +17191,10 @@ async function quoteTokenShortfallRecovery(params) {
 		reason: "invalid-shortfall",
 		detail: `requested=${shortfallError.assetsRequested} <= balance=${shortfallError.assetBalance}`
 	};
-	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$4) return {
+	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$5) return {
 		available: false,
 		reason: "invalid-slippage",
-		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$4}]`
+		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$5}]`
 	};
 	const targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
 	const pool = await getPool({
@@ -17183,8 +17342,9 @@ async function quoteTokenShortfallRecovery(params) {
 			error: new PanopticError("Could not size the prefixed recovery swap")
 		};
 	};
+	let creditOutSize = amountOut;
 	for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
-		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, amountOut);
+		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditOutSize);
 		const recoveredDispatch = buildTokenShortfallRecoveryDispatch({
 			dispatch: params.dispatch,
 			creditTokenId: credit.tokenId,
@@ -17228,10 +17388,14 @@ async function quoteTokenShortfallRecovery(params) {
 		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
-		if (swapOutput < amountOut || sourceBalance < maxAmountIn) return {
+		if (swapOutput < amountOut) {
+			creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			continue;
+		}
+		if (sourceBalance < maxAmountIn) return {
 			available: false,
 			reason: "swap-unavailable",
-			detail: swapOutput < amountOut ? `swap output ${swapOutput} < required ${amountOut}` : `source balance ${sourceBalance} < maximumAmountIn ${maxAmountIn} (estimated ${estimatedAmountIn}, slippageBps ${params.slippageBps})`,
+			detail: `source balance ${sourceBalance} < maximumAmountIn ${maxAmountIn} (estimated ${estimatedAmountIn}, slippageBps ${params.slippageBps})`,
 			error: new PanopticError("Insufficient source collateral for the recovery swap")
 		};
 		const recoverySimulation = await simulateDispatch({
@@ -17283,6 +17447,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const decodedShortfall = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
 		amountOut += additionalAmountOut;
+		creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return {
 		available: false,
@@ -17309,6 +17474,7 @@ const MAX_EFFECTIVE_LIQUIDITY_LIMIT = 8388607;
 * returned value must be scaled down to the caller's actual `positionSize`.
 */
 const MAX_UINT64$1 = 2n ** 64n - 1n;
+const FP96$1 = 1n << 96n;
 /**
 * `getRequiredBase` returns `type(uint128).max` as an error sentinel (invalid
 * tokenId or reverting `getMargin`). Detect it so we don't scale a garbage value.
@@ -17321,7 +17487,9 @@ const REQUIRED_BASE_ERROR_SENTINEL = 2n ** 128n - 1n;
 * computes the requirement at `type(uint64).max` size and 0% utilization. Since
 * the requirement is linear in size, the raw result is scaled by
 * `positionSize / type(uint64).max` to yield the requirement for the requested
-* size. Returns collateral requirement in terms of token0.
+* size. `PanopticQuery.getRequiredBase` returns the cross-margin requirement in
+* the higher-precision raw token at `atTick`; this function places that amount
+* in the matching `required0` or `required1` field.
 *
 * @param params - The parameters
 * @returns Estimated collateral requirements with block metadata
@@ -17340,7 +17508,7 @@ async function estimateCollateralRequired(params) {
 		});
 		effectiveTick = BigInt(currentTickResult);
 	}
-	const [required0, _meta] = await Promise.all([client.readContract({
+	const [requiredBase, _meta] = await Promise.all([client.readContract({
 		address: queryAddress,
 		abi: panopticQueryAbi,
 		functionName: "getRequiredBase",
@@ -17354,10 +17522,11 @@ async function estimateCollateralRequired(params) {
 		client,
 		blockNumber: targetBlockNumber
 	})]);
-	const scaled0 = required0 >= REQUIRED_BASE_ERROR_SENTINEL ? required0 : required0 * positionSize / MAX_UINT64$1;
+	const scaledRequirement = requiredBase >= REQUIRED_BASE_ERROR_SENTINEL ? requiredBase : requiredBase * positionSize / MAX_UINT64$1;
+	const denominatedInToken0 = tickToSqrtPriceX96(effectiveTick) < FP96$1;
 	return {
-		required0: scaled0,
-		required1: 0n,
+		required0: denominatedInToken0 ? scaledRequirement : 0n,
+		required1: denominatedInToken0 ? 0n : scaledRequirement,
 		_meta
 	};
 }
@@ -20994,7 +21163,9 @@ async function getStreamiaHistory(params) {
 			_meta: _meta$1
 		};
 	}
-	const premiaRequests = blockNumbers.map((bn) => client.readContract({
+	const _meta = params._meta ?? await getBlockMeta({ client });
+	const resolvedBlockNumbers = blockNumbers.map((blockNumber) => blockNumber ?? _meta.blockNumber);
+	const premiaRequests = resolvedBlockNumbers.map((blockNumber) => client.readContract({
 		address: panopticPoolAddress,
 		abi: panopticPoolV2Abi,
 		functionName: "getFullPositionsData",
@@ -21003,18 +21174,36 @@ async function getStreamiaHistory(params) {
 			true,
 			[tokenId]
 		],
-		blockNumber: bn
+		blockNumber
 	}));
-	const uniswapDataPromise = includeUniswapFees && legs.length > 0 ? fetchUniswapFeeData(client, blockNumbers, legs, poolConfig) : void 0;
-	const [premiaResults, uniswapData, _meta] = await Promise.all([
-		Promise.all(premiaRequests),
-		uniswapDataPromise ?? Promise.resolve(void 0),
-		params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })
-	]);
-	const sortedSettled = settledEvents ? [...settledEvents].sort((a, b) => a.blockNumber < b.blockNumber ? -1 : 1) : [];
+	const uniswapDataPromise = includeUniswapFees && legs.length > 0 ? fetchUniswapFeeData(client, resolvedBlockNumbers, legs, poolConfig) : void 0;
+	const [premiaResults, uniswapData] = await Promise.all([Promise.all(premiaRequests), uniswapDataPromise ?? Promise.resolve(void 0)]);
+	const sortedSettled = settledEvents ? [...settledEvents].sort((a, b) => a.blockNumber === b.blockNumber ? 0 : a.blockNumber < b.blockNumber ? -1 : 1) : [];
 	let settledIdx = 0;
 	let accSettled0 = 0n;
 	let accSettled1 = 0n;
+	const cumulativePremiaByInputIndex = Array.from({ length: blockNumbers.length }, () => ({
+		token0: 0n,
+		token1: 0n
+	}));
+	const chronologicalInputs = resolvedBlockNumbers.map((blockNumber, inputIndex) => ({
+		blockNumber,
+		inputIndex
+	})).sort((a, b) => a.blockNumber === b.blockNumber ? a.inputIndex - b.inputIndex : a.blockNumber < b.blockNumber ? -1 : 1);
+	for (const { blockNumber, inputIndex } of chronologicalInputs) {
+		while (settledIdx < sortedSettled.length && sortedSettled[settledIdx].blockNumber <= blockNumber) {
+			accSettled0 += sortedSettled[settledIdx].settled0;
+			accSettled1 += sortedSettled[settledIdx].settled1;
+			settledIdx++;
+		}
+		const result = premiaResults[inputIndex];
+		const premia0 = (result[0] & MASK_128) - (result[1] & MASK_128);
+		const premia1 = (result[0] >> 128n) - (result[1] >> 128n);
+		cumulativePremiaByInputIndex[inputIndex] = {
+			token0: premia0 + accSettled0,
+			token1: premia1 + accSettled1
+		};
+	}
 	let initialUniswapFees0 = null;
 	let initialUniswapFees1 = null;
 	const snapshots = premiaResults.map((result, i) => {
@@ -21025,14 +21214,8 @@ async function getStreamiaHistory(params) {
 		const short1 = shortPacked >> 128n;
 		const long0 = longPacked & MASK_128;
 		const long1 = longPacked >> 128n;
-		const effectiveBn = bn ?? BigInt(Number.MAX_SAFE_INTEGER);
-		while (settledIdx < sortedSettled.length && sortedSettled[settledIdx].blockNumber <= effectiveBn) {
-			accSettled0 += sortedSettled[settledIdx].settled0;
-			accSettled1 += sortedSettled[settledIdx].settled1;
-			settledIdx++;
-		}
-		const premia0 = short0 - long0 - accSettled0;
-		const premia1 = short1 - long1 - accSettled1;
+		const premia0 = short0 - long0;
+		const premia1 = short1 - long1;
 		let uniswapFees0 = 0n;
 		let uniswapFees1 = 0n;
 		if (uniswapData) {
@@ -21051,6 +21234,7 @@ async function getStreamiaHistory(params) {
 				token0: premia0,
 				token1: premia1
 			},
+			cumulativePanopticPremia: cumulativePremiaByInputIndex[i],
 			uniswapFees: {
 				token0: uniswapFees0,
 				token1: uniswapFees1
@@ -21839,7 +22023,7 @@ const nfpmAbi = [{
 	}],
 	stateMutability: "payable"
 }];
-const MAX_UINT128 = 2n ** 128n - 1n;
+const MAX_UINT128$1 = 2n ** 128n - 1n;
 const MAX_UINT256 = 2n ** 256n - 1n;
 const Q128 = 2n ** 128n;
 /**
@@ -21881,8 +22065,8 @@ async function getUniswapV3LpPositionState(params) {
 			args: [{
 				tokenId,
 				recipient: owner,
-				amount0Max: MAX_UINT128,
-				amount1Max: MAX_UINT128
+				amount0Max: MAX_UINT128$1,
+				amount1Max: MAX_UINT128$1
 			}],
 			account: owner,
 			blockNumber: _meta.blockNumber
@@ -22032,6 +22216,31 @@ async function fetchSlot0(client, blockNumber, poolConfig) {
 	}
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/positionSizes.ts
+const BIT_MASK_128$1 = (1n << 128n) - 1n;
+/**
+* Returns the current stored positionSize for each tokenId, in the same order
+* as the input `positionIdList`. Reverts (via the contract) if any tokenId is
+* not held by `account`.
+*/
+async function getCurrentPositionSizes(params) {
+	const { client, poolAddress, account, positionIdList, blockNumber } = params;
+	if (positionIdList.length === 0) return [];
+	const [, , positionBalances] = await client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			false,
+			positionIdList
+		],
+		blockNumber
+	});
+	return positionBalances.map((packed) => packed & BIT_MASK_128$1);
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/enrichment.ts
 /**
@@ -24065,8 +24274,14 @@ async function forceExerciseAndWait(params) {
 * ```
 */
 async function settleAccumulatedPremia(params) {
-	const { client, walletClient, account, poolAddress, positionIdList, usePremiaAsCollateral = false, builderCode = 0n, txOverrides } = params;
-	const positionSizes = positionIdList.map(() => 0n);
+	const { client, walletClient, account, poolAddress, positionIdList, finalPositionIdList, positionSizes: providedSizes, usePremiaAsCollateral = false, builderCode = 0n, txOverrides } = params;
+	if (providedSizes && providedSizes.length !== positionIdList.length) throw new PanopticError("settleAccumulatedPremia: positionSizes length must match positionIdList");
+	const positionSizes = providedSizes ?? await getCurrentPositionSizes({
+		client,
+		poolAddress,
+		account,
+		positionIdList
+	});
 	const tickAndSpreadLimits = positionIdList.map(() => [
 		-887272n,
 		887272n,
@@ -24081,7 +24296,7 @@ async function settleAccumulatedPremia(params) {
 		functionName: "dispatch",
 		args: [
 			positionIdList,
-			positionIdList,
+			finalPositionIdList ?? positionIdList,
 			positionSizes.map((s) => BigInt(s)),
 			tickAndSpreadLimits.map((t) => [
 				Number(t[0]),
@@ -25662,14 +25877,21 @@ const multicallAbi = [{
 * @returns Simulation result with settlement data or error
 */
 async function simulateSettle(params) {
-	const { client, poolAddress, account, positionIdList, tokenId, blockNumber } = params;
+	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes: providedSizes, tokenId, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
 	try {
-		const positionSizes = positionIdList.map(() => 0n);
+		if (providedSizes && providedSizes.length !== positionIdList.length) throw new PanopticError("simulateSettle: positionSizes length must match positionIdList");
+		const positionSizes = providedSizes ?? await getCurrentPositionSizes({
+			client,
+			poolAddress,
+			account,
+			positionIdList,
+			blockNumber: targetBlockNumber
+		});
 		const tickAndSpreadLimits = positionIdList.map(() => [
 			-887272n,
 			887272n,
@@ -25680,7 +25902,7 @@ async function simulateSettle(params) {
 			functionName: "dispatch",
 			args: [
 				positionIdList,
-				positionIdList,
+				finalPositionIdList ?? positionIdList,
 				positionSizes.map((s) => BigInt(s)),
 				tickAndSpreadLimits.map((t) => [
 					Number(t[0]),
@@ -25712,8 +25934,8 @@ async function simulateSettle(params) {
 		});
 		const _meta = await metaPromise;
 		const data = {
-			premiaReceived0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
-			premiaReceived1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
+			premiaReceived0: tokenFlow.delta0,
+			premiaReceived1: tokenFlow.delta1,
 			postCollateral0: tokenFlow.balanceAfter0,
 			postCollateral1: tokenFlow.balanceAfter1,
 			forfeitAmounts
@@ -26225,7 +26447,7 @@ async function simulateSwapExactIn(params) {
 
 //#endregion
 //#region src/panoptic/v2/simulations/oneTokenFlow.ts
-const BPS_DENOMINATOR$3 = 10000n;
+const BPS_DENOMINATOR$4 = 10000n;
 /**
 * Default {@link OneTokenFlowQuoteParams.minSwapRatioBps}: 0.5%.
 *
@@ -26245,7 +26467,7 @@ function abs(value) {
 	return value < 0n ? -value : value;
 }
 function padForSlippage(amount, slippageBps) {
-	return (amount * (BPS_DENOMINATOR$3 + slippageBps) + BPS_DENOMINATOR$3 - 1n) / BPS_DENOMINATOR$3;
+	return (amount * (BPS_DENOMINATOR$4 + slippageBps) + BPS_DENOMINATOR$4 - 1n) / BPS_DENOMINATOR$4;
 }
 /**
 * Quote a dispatch wrapped so its net flow lands in `targetTokenIndex` only.
@@ -26265,10 +26487,10 @@ async function quoteOneTokenFlow(params) {
 		reason: "invalid-target-token",
 		detail: `targetTokenIndex=${targetTokenIndex} is neither 0 nor 1`
 	};
-	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$3) return {
+	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$4) return {
 		available: false,
 		reason: "invalid-slippage",
-		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$3}]`
+		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$4}]`
 	};
 	const tickLimitLow = params.tickLimitLow ?? MIN_TICK;
 	const tickLimitHigh = params.tickLimitHigh ?? MAX_TICK;
@@ -26376,7 +26598,7 @@ async function quoteOneTokenFlow(params) {
 	}
 	if (baseTargetDelta !== null && minSwapRatioBps > 0n) {
 		const swapInTargetTerms = convertToTokenIndex(swapAmount, otherTokenIndex, targetTokenIndex, pool.sqrtPriceX96);
-		if (swapInTargetTerms * BPS_DENOMINATOR$3 < minSwapRatioBps * abs(baseTargetDelta)) return {
+		if (swapInTargetTerms * BPS_DENOMINATOR$4 < minSwapRatioBps * abs(baseTargetDelta)) return {
 			available: false,
 			reason: "below-threshold",
 			detail: `non-target flow ${swapInTargetTerms} (in target token terms) is below ${minSwapRatioBps}bps of the target flow ${abs(baseTargetDelta)}`
@@ -26468,6 +26690,200 @@ async function quoteOneTokenFlow(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/simulations/temporaryLoanRecovery.ts
+const BPS_DENOMINATOR$3 = 10000n;
+const MAX_RECOVERY_ATTEMPTS = 8n;
+const MAX_UINT128 = (1n << 128n) - 1n;
+const LOAN_GROWTH_DENOMINATOR = 20n;
+/**
+* Wrap a dispatch with `loan mint -> user operations -> swapped loan burn`.
+* The repeated tokenId is intentional: the first occurrence mints it and the
+* last occurrence burns it after the user's operations have settled.
+*/
+function buildTemporaryLoanRecoveryDispatch(params) {
+	const low = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitLow : params.tickLimitHigh;
+	const high = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitHigh : params.tickLimitLow;
+	return {
+		positionIdList: [
+			params.loanTokenId,
+			...params.dispatch.positionIdList,
+			params.loanTokenId
+		],
+		finalPositionIdList: [...params.dispatch.finalPositionIdList],
+		positionSizes: [
+			params.loanPositionSize,
+			...params.dispatch.positionSizes,
+			0n
+		],
+		tickAndSpreadLimits: [
+			[
+				low,
+				high,
+				0n
+			],
+			...params.dispatch.tickAndSpreadLimits,
+			[
+				high,
+				low,
+				0n
+			]
+		],
+		usePremiaAsCollateral: params.dispatch.usePremiaAsCollateral,
+		builderCode: params.dispatch.builderCode
+	};
+}
+/**
+* Quotes and simulates an atomic temporary loan around a full-close dispatch.
+*
+* @param params - Chain client, account, failed dispatch, shortfall error, and quote limits.
+* @returns An executable quote when recovery succeeds, otherwise a categorized unavailable result.
+* @throws {PanopticError} When the dispatch is not a full close or required RPC reads fail.
+*/
+async function quoteTemporaryLoanRecovery(params) {
+	const initialShortfall = getNotEnoughTokensError(params.error);
+	if (initialShortfall === null) return {
+		available: false,
+		reason: "not-token-shortfall"
+	};
+	let loanAmount = initialShortfall.assetsRequested - initialShortfall.assetBalance;
+	if (loanAmount <= 0n) return {
+		available: false,
+		reason: "invalid-shortfall",
+		detail: `requested=${initialShortfall.assetsRequested} <= balance=${initialShortfall.assetBalance}`
+	};
+	if (params.slippageBps <= 0n || params.slippageBps > BPS_DENOMINATOR$3) return {
+		available: false,
+		reason: "invalid-slippage",
+		detail: `slippageBps=${params.slippageBps} is outside (0, ${BPS_DENOMINATOR$3}]`
+	};
+	if (params.dispatch.finalPositionIdList.length !== 0) throw new PanopticError("Temporary-loan recovery requires a full-close dispatch with an empty finalPositionIdList");
+	let targetBlockNumber;
+	try {
+		targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+	} catch (error) {
+		if (error instanceof PanopticError) throw error;
+		throw new PanopticError("Failed to resolve the block for temporary-loan recovery", error instanceof Error ? error : new Error(String(error)));
+	}
+	let pool;
+	try {
+		pool = await getPool({
+			client: params.client,
+			poolAddress: params.poolAddress,
+			chainId: params.chainId,
+			blockNumber: targetBlockNumber
+		});
+	} catch (error) {
+		if (error instanceof PanopticError) throw error;
+		throw new PanopticError("Failed to load the pool for temporary-loan recovery", error instanceof Error ? error : new Error(String(error)));
+	}
+	const defaultLimits = tickLimits(pool.currentTick, params.slippageBps);
+	const tickLimitLow = params.tickLimitLow ?? defaultLimits.low;
+	const tickLimitHigh = params.tickLimitHigh ?? defaultLimits.high;
+	if (tickLimitLow >= tickLimitHigh) return {
+		available: false,
+		reason: "invalid-tick-limits",
+		detail: `tickLimitLow=${tickLimitLow} >= tickLimitHigh=${tickLimitHigh}`
+	};
+	const token0 = pool.collateralTracker0.token;
+	const token1 = pool.collateralTracker1.token;
+	const tokenIndexFor = (address) => {
+		const normalized = address.toLowerCase();
+		if (normalized === token0.toLowerCase() || normalized === pool.collateralTracker0.address.toLowerCase()) return 0n;
+		if (normalized === token1.toLowerCase() || normalized === pool.collateralTracker1.address.toLowerCase()) return 1n;
+		return null;
+	};
+	const loanTokenIndex = tokenIndexFor(initialShortfall.tokenAddress);
+	if (loanTokenIndex === null) return {
+		available: false,
+		reason: "unsupported-token",
+		detail: `${initialShortfall.tokenAddress} is neither collateral token of ${params.poolAddress}`
+	};
+	const repaymentTokenIndex = loanTokenIndex === 0n ? 1n : 0n;
+	const loanToken = loanTokenIndex === 0n ? token0 : token1;
+	const repaymentToken = repaymentTokenIndex === 0n ? token0 : token1;
+	const collisionIds = Array.from(new Set([
+		...params.existingPositionIds,
+		...params.dispatch.positionIdList,
+		...params.dispatch.finalPositionIdList
+	]));
+	for (let attempt = 0n; attempt < MAX_RECOVERY_ATTEMPTS; attempt += 1n) {
+		if (loanAmount > MAX_UINT128) return {
+			available: false,
+			reason: "recovery-unavailable",
+			detail: `required loan amount ${loanAmount} exceeds uint128`
+		};
+		const loan = buildUniqueLoan(pool.poolId, loanTokenIndex, loanTokenIndex, pool.currentTick, pool.tickSpacing, collisionIds, loanAmount);
+		const recoveredDispatch = buildTemporaryLoanRecoveryDispatch({
+			dispatch: params.dispatch,
+			loanTokenId: loan.tokenId,
+			loanPositionSize: loan.adjustedSize,
+			tickLimitLow,
+			tickLimitHigh
+		});
+		const simulation = await simulateDispatch({
+			client: params.client,
+			poolAddress: params.poolAddress,
+			account: params.account,
+			existingPositionIdList: params.existingPositionIds,
+			...recoveredDispatch,
+			blockNumber: targetBlockNumber
+		});
+		if (simulation.success && simulation.tokenFlow !== void 0) {
+			const tokenFlow = simulation.tokenFlow;
+			return {
+				available: true,
+				quote: {
+					loanToken,
+					repaymentToken,
+					loanTokenIndex,
+					loanAmount,
+					loanPositionSize: loan.adjustedSize,
+					loanTokenId: loan.tokenId,
+					slippageBps: params.slippageBps,
+					netLoanTokenChange: loanTokenIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1,
+					netRepaymentTokenChange: repaymentTokenIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1,
+					dispatch: recoveredDispatch,
+					simulation: {
+						...simulation,
+						tokenFlow
+					},
+					tokenFlow,
+					_meta: simulation._meta
+				}
+			};
+		}
+		if (simulation.success) return {
+			available: false,
+			reason: "recovery-unavailable",
+			detail: "temporary-loan simulation returned no token flow"
+		};
+		const shortfall = getNotEnoughTokensError(simulation.error);
+		if (shortfall === null) return {
+			available: false,
+			reason: "recovery-unavailable",
+			detail: `temporary-loan dispatch reverted: ${simulation.error.message}`,
+			error: simulation.error
+		};
+		const shortfallIndex = tokenIndexFor(shortfall.tokenAddress);
+		if (shortfallIndex !== loanTokenIndex) return {
+			available: false,
+			reason: "repayment-token-shortfall",
+			detail: `repayment token ${shortfall.tokenAddress} requested ${shortfall.assetsRequested}, balance ${shortfall.assetBalance}`,
+			error: simulation.error
+		};
+		const residual = shortfall.assetsRequested - shortfall.assetBalance;
+		const geometricGrowth = (loanAmount + LOAN_GROWTH_DENOMINATOR - 1n) / LOAN_GROWTH_DENOMINATOR;
+		loanAmount += residual > geometricGrowth ? residual : geometricGrowth;
+	}
+	return {
+		available: false,
+		reason: "recovery-unavailable",
+		detail: `temporary-loan recovery remained short after ${MAX_RECOVERY_ATTEMPTS} attempts`,
+		error: new PanopticError("Could not size the temporary loan within the quote attempt limit")
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/abis/poolManager.ts
 /**
@@ -33299,5 +33715,5 @@ function useTxEventConfirmation({ txHash, poolAddress = zeroAddress, collateralT
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, 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, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, 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, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, 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, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, 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, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, 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, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteOneTokenFlow, quoteSfpmSwap, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, 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, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, 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, 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, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, 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, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, 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, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, 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, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, 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, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, 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, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, 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, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, 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, 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, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=react-public.js.map