@panoptic-eng/sdk 1.0.40 → 1.0.41

package/dist/panoptic/v2/index.js

@@ -10024,1502 +10024,1661 @@ 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
-	};
+function tickToPrice(tick) {
+	const { numerator, denominator } = getRawPriceRatio(tick);
+	const price = formatRatio$3(numerator, denominator, RAW_PRICE_PRECISION);
+	return trimTrailingZeros(price);
 }
-
-//#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)
-	};
+/**
+* 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)
+* ```
+*/
+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);
 }
-/** 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);
+/**
+* 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"
+* ```
+*/
+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);
 }
 /**
-* 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 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
+* ```
 */
-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 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;
 }
-
-//#endregion
-//#region src/uniswap/v4/router/errors.ts
 /**
-* The chain has no configured Uniswap v4 addresses and none were supplied via
-* overrides.
+* 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 UnsupportedChainError = class extends PanopticError {
-	name = "UnsupportedChainError";
-	constructor(chainId, cause) {
-		super(`Uniswap v4 router not configured 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$1 = (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$3 = 10000n;
-const UINT128_MAX = (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) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
-	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$3) 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$3 - slippageBps) / BPS_DENOMINATOR$3;
-		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)`.
+* @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 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
-	};
+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;
-	};
-	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"
+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
 	};
-	throw new Error(`No PanopticPool found for poolId ${poolId}`);
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
-const MASK_80 = (1n << 80n) - 1n;
-const MASK_40 = (1n << 40n) - 1n;
-const MASK_96 = (1n << 96n) - 1n;
-
-//#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
+//#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);
+}
 /**
-* Minimal Uniswap V3 Pool ABI for fee growth reads.
-* Only includes functions needed by streamia history.
+* 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 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"
+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
+		};
+	}
+}
+
+//#endregion
+//#region src/uniswap/v4/router/errors.ts
+/**
+* The chain has no configured Uniswap v4 addresses and none were supplied via
+* overrides.
+*/
+var UnsupportedChainError = class extends PanopticError {
+	name = "UnsupportedChainError";
+	constructor(chainId, cause) {
+		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
+		this.chainId = chainId;
+	}
+};
+
+//#endregion
+//#region src/uniswap/v3/router/encodeSwap.ts
+const UINT128_MAX$1 = (1n << 128n) - 1n;
+
+//#endregion
+//#region src/uniswap/v3/abis/quoterV2.ts
+/**
+* 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 quoterV2Abi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
 			{
-				internalType: "int128",
-				name: "liquidityNet",
-				type: "int128"
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "feeGrowthOutside0X128",
-				type: "uint256"
+				name: "tokenOut",
+				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "feeGrowthOutside1X128",
+				name: "amountIn",
 				type: "uint256"
 			},
 			{
-				internalType: "int56",
-				name: "tickCumulativeOutside",
-				type: "int56"
+				name: "fee",
+				type: "uint24"
 			},
 			{
-				internalType: "uint160",
-				name: "secondsPerLiquidityOutsideX128",
+				name: "sqrtPriceLimitX96",
 				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"
-	}
-];
+		]
+	}],
+	outputs: [
+		{
+			name: "amountOut",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}];
 
 //#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;
-}
-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 {
-		numerator,
-		denominator
+//#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.
+*/
+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;
 }
-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;
+
+//#endregion
+//#region src/uniswap/v3/router/quote.ts
+const BPS_DENOMINATOR$3 = 10000n;
+const UINT128_MAX = (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) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$3) 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$3 - slippageBps) / BPS_DENOMINATOR$3;
+		return {
+			amountOut,
+			amountOutMinimum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert(err)) return null;
+		throw err;
+	}
 }
-const MIN_SQRT_PRICE_X96 = tickToSqrtPriceX96(MIN_TICK);
-const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
-function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
-	return {
-		numerator: sqrtPriceX96 * sqrtPriceX96,
-		denominator: Q192$3
-	};
+/** 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 getRawPriceRatio(tick) {
-	return getPriceRatioFromSqrtPriceX96(tickToSqrtPriceX96(tick));
+
+//#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 adjustRatioForDecimals(numerator, denominator, decimals0, decimals1) {
-	const diff = decimals0 - decimals1;
-	if (diff === 0n) return {
-		numerator,
-		denominator
-	};
-	if (diff > 0n) return {
-		numerator: numerator * pow10(diff),
-		denominator
-	};
+/**
+* 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: denominator * pow10(-diff)
+		currency0: raw.currency0,
+		currency1: raw.currency1,
+		fee: BigInt(raw.fee),
+		tickSpacing: BigInt(raw.tickSpacing),
+		hooks: raw.hooks
 	};
 }
 /**
-* 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
+* Get the enforced tick limits for a pool from the SFPM.
 *
-* @example
-* ```typescript
-* tickToPrice(0n)       // "1"
-* tickToPrice(1000n)    // "1.105..." (approximately)
-* tickToPrice(-1000n)   // "0.904..." (approximately)
-* tickToPrice(200000n)  // Very large number
-* ```
+* @param params - The parameters
+* @returns The min and max enforced ticks
 */
-function tickToPrice(tick) {
-	const { numerator, denominator } = getRawPriceRatio(tick);
-	const price = formatRatio$3(numerator, denominator, RAW_PRICE_PRECISION);
-	return trimTrailingZeros(price);
+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
+	};
 }
 /**
-* 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)
+* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
 *
-* // For token1/token0 price, swap the decimals
-* tickToPriceDecimalScaled(200000n, 6n, 18n, 6n) // "0.000500" (approximately)
-* ```
+* Uses multicall for efficiency. Returns one result per input chunk,
+* along with block metadata for freshness tracking.
 */
-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 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 {
+		results,
+		_meta
+	};
 }
-/**
-* 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"
-* ```
+
+//#endregion
+//#region src/panoptic/v2/reads/factory.ts
+/**
+* Get the token URI from a PanopticFactory NFT.
 */
-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);
+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 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
-* ```
+* Get the owner of a PanopticFactory NFT.
 */
-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;
+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 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
-* ```
+* Construct NFT metadata for a pool via the factory contract.
 */
-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}`;
+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
+	});
 }
 /**
-* Calculate the tick spacing for a given fee tier.
+* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
 *
-* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
-* @returns Tick spacing
+* 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.
 *
-* @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)
-* ```
+* 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
+const MASK_80 = (1n << 80n) - 1n;
+const MASK_40 = (1n << 40n) - 1n;
+const MASK_96 = (1n << 96n) - 1n;
+
+//#endregion
+//#region src/panoptic/v2/abis/stateView.ts
 /**
-* 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
-* ```
+* Minimal Uniswap V4 StateView ABI for fee growth reads.
+* Only includes functions needed by streamia history.
 */
-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 })
-* ```
+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.
 */
-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
-	};
-}
+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"
+	}
+];
 
 //#endregion
 //#region src/panoptic/v2/reads/mintBuffer.ts
@@ -14525,7 +14684,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;
@@ -14676,7 +14835,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,
@@ -16919,8 +17078,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,
@@ -16964,10 +17124,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({
@@ -17019,6 +17183,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,
@@ -17045,6 +17210,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.
@@ -17057,7 +17223,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
@@ -17076,7 +17244,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",
@@ -17090,10 +17258,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
 	};
 }
@@ -20730,7 +20899,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",
@@ -20739,18 +20910,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) => {
@@ -20761,14 +20950,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) {
@@ -20787,6 +20970,7 @@ async function getStreamiaHistory(params) {
 				token0: premia0,
 				token1: premia1
 			},
+			cumulativePanopticPremia: cumulativePremiaByInputIndex[i],
 			uniswapFees: {
 				token0: uniswapFees0,
 				token1: uniswapFees1
@@ -21768,6 +21952,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
 /**
@@ -23801,8 +24010,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,
@@ -23817,7 +24032,7 @@ async function settleAccumulatedPremia(params) {
 		functionName: "dispatch",
 		args: [
 			positionIdList,
-			positionIdList,
+			finalPositionIdList ?? positionIdList,
 			positionSizes.map((s) => BigInt(s)),
 			tickAndSpreadLimits.map((t) => [
 				Number(t[0]),
@@ -25398,14 +25613,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,
@@ -25416,7 +25638,7 @@ async function simulateSettle(params) {
 			functionName: "dispatch",
 			args: [
 				positionIdList,
-				positionIdList,
+				finalPositionIdList ?? positionIdList,
 				positionSizes.map((s) => BigInt(s)),
 				tickAndSpreadLimits.map((t) => [
 					Number(t[0]),
@@ -25448,8 +25670,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
@@ -27871,5 +28093,5 @@ const VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN = {
 };
 
 //#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, 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, 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, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, 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, 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, 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, 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, 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, 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, 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, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=index.js.map