@panoptic-eng/sdk 1.0.47 → 1.0.48

package/dist/panoptic/v2/index.js

@@ -435,6 +435,19 @@ var SwapTokenMismatchError = class extends PanopticError {
 		this.token1 = token1;
 	}
 };
+/**
+* A premium settlement would advance the seller checkpoint while some
+* displayed premium is still unavailable, or a required buyer cannot settle.
+*/
+var UnsafePremiumSettlementError = class extends PanopticError {
+	name = "UnsafePremiumSettlementError";
+	constructor(remainingForfeit, failedBuyerCount, cause) {
+		const [token0, token1] = remainingForfeit;
+		super(failedBuyerCount > 0 ? `Premium settlement blocked: ${failedBuyerCount} buyer settlement${failedBuyerCount === 1 ? "" : "s"} would fail` : `Premium settlement blocked: uncollectable premium remains (${token0}, ${token1})`, cause);
+		this.remainingForfeit = remainingForfeit;
+		this.failedBuyerCount = failedBuyerCount;
+	}
+};
 
 //#endregion
 //#region src/panoptic/v2/utils/interpolateBlocks.ts
@@ -10037,7 +10050,7 @@ function hasLoanOrCredit(tokenId) {
 //#region src/panoptic/v2/formatters/tick.ts
 const Q192$5 = 1n << 192n;
 const RAW_PRICE_PRECISION = 40n;
-function pow10$1(exponent) {
+function pow10$2(exponent) {
 	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
 	return 10n ** exponent;
 }
@@ -10056,7 +10069,7 @@ 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$1(precision);
+	const scale = pow10$2(precision);
 	const scaled = (absNumerator * scale + denominator / 2n) / denominator;
 	const integerPart = scaled / scale;
 	const fractionalPart = scaled % scale;
@@ -10074,11 +10087,11 @@ function parseDecimalToFraction(value) {
 	const integerDigits = integerStr === "" ? "0" : integerStr;
 	const digits = `${integerDigits}${fractionalStr}`;
 	let numerator = BigInt(digits === "" ? "0" : digits);
-	let denominator = pow10$1(BigInt(fractionalStr.length));
+	let denominator = pow10$2(BigInt(fractionalStr.length));
 	if (exponentPart !== void 0 && exponentPart !== "") {
 		const exponent = BigInt(exponentPart);
-		if (exponent > 0n) numerator *= pow10$1(exponent);
-		else if (exponent < 0n) denominator *= pow10$1(-exponent);
+		if (exponent > 0n) numerator *= pow10$2(exponent);
+		else if (exponent < 0n) denominator *= pow10$2(-exponent);
 	}
 	if (isNegative) numerator = -numerator;
 	return {
@@ -10138,12 +10151,12 @@ function adjustRatioForDecimals(numerator, denominator, decimals0, decimals1) {
 		denominator
 	};
 	if (diff > 0n) return {
-		numerator: numerator * pow10$1(diff),
+		numerator: numerator * pow10$2(diff),
 		denominator
 	};
 	return {
 		numerator,
-		denominator: denominator * pow10$1(-diff)
+		denominator: denominator * pow10$2(-diff)
 	};
 }
 /**
@@ -10240,16 +10253,16 @@ function priceToTick(price, decimals0, decimals1) {
 	let targetNumerator = parsed.numerator;
 	let targetDenominator = parsed.denominator;
 	const diff = decimals0 - decimals1;
-	if (diff > 0n) targetDenominator *= pow10$1(diff);
-	else if (diff < 0n) targetNumerator *= pow10$1(-diff);
+	if (diff > 0n) targetDenominator *= pow10$2(diff);
+	else if (diff < 0n) targetNumerator *= pow10$2(-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;
+		const cmp$1 = compareRatios(numerator, denominator, targetNumerator, targetDenominator);
+		if (cmp$1 === 0) return mid;
+		if (cmp$1 < 0) low = mid + 1n;
 		else high = mid - 1n;
 	}
 	const floorTick = high;
@@ -10459,7 +10472,7 @@ function tickLimits(currentTick, toleranceBps) {
 
 //#endregion
 //#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
-const POOL_ID_MASK$3 = (1n << 64n) - 1n;
+const POOL_ID_MASK$4 = (1n << 64n) - 1n;
 const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
 const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
 const Q192$4 = 1n << 192n;
@@ -10566,7 +10579,7 @@ function scaleRatios(baseTokenId, targetPositionSize) {
 	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$3;
+	const poolId = baseTokenId & POOL_ID_MASK$4;
 	let out = poolId;
 	for (const leg of legs) out = addLegToTokenId(out, {
 		index: leg.index,
@@ -11380,14 +11393,14 @@ function formatGwei(wei, precision) {
 //#endregion
 //#region src/panoptic/v2/tokenId/generateOverlapping.ts
 const MAX_UINT64$2 = (1n << 64n) - 1n;
-const MAX_UINT128$3 = (1n << 128n) - 1n;
+const MAX_UINT128$4 = (1n << 128n) - 1n;
 const Q192$3 = 1n << 192n;
 const MAX_TOKEN_DECIMALS = 255n;
 const MAX_DECIMAL_EXPONENT = 512n;
 function invalid$1(message) {
 	throw new PanopticValidationError(`generateOverlappingTokenIds: ${message}`);
 }
-function pow10(exponent) {
+function pow10$1(exponent) {
 	return 10n ** exponent;
 }
 function parsePriceSpacing(value, quoteDecimals) {
@@ -11400,7 +11413,7 @@ function parsePriceSpacing(value, quoteDecimals) {
 	let units = BigInt(`${integerPart}${fractionalPart}`);
 	let scale = BigInt(fractionalPart.length) - exponent;
 	if (scale < 0n) {
-		units *= pow10(-scale);
+		units *= pow10$1(-scale);
 		scale = 0n;
 	}
 	while (scale > 0n && units % 10n === 0n) {
@@ -11412,7 +11425,7 @@ function parsePriceSpacing(value, quoteDecimals) {
 	return {
 		units,
 		scale,
-		denominator: pow10(scale)
+		denominator: pow10$1(scale)
 	};
 }
 function formatGridPrice(multiple, spacing) {
@@ -11429,8 +11442,8 @@ function quotePriceAtTick(tick, asset, assetDecimals, quoteDecimals) {
 	let numerator = sqrtPriceX96 * sqrtPriceX96;
 	let denominator = Q192$3;
 	const decimalDifference = assetDecimals - quoteDecimals;
-	if (decimalDifference > 0n) numerator *= pow10(decimalDifference);
-	else if (decimalDifference < 0n) denominator *= pow10(-decimalDifference);
+	if (decimalDifference > 0n) numerator *= pow10$1(decimalDifference);
+	else if (decimalDifference < 0n) denominator *= pow10$1(-decimalDifference);
 	return {
 		numerator,
 		denominator
@@ -11447,12 +11460,12 @@ function isPriceGridStrike(strike, params, spacing, tickSpacing) {
 	}
 	return false;
 }
-function ceilDiv$1(value, divisor) {
+function ceilDiv$3(value, divisor) {
 	const quotient = value / divisor;
 	const remainder = value % divisor;
 	return remainder > 0n ? quotient + 1n : quotient;
 }
-function floorDiv(value, divisor) {
+function floorDiv$1(value, divisor) {
 	const quotient = value / divisor;
 	const remainder = value % divisor;
 	return remainder < 0n ? quotient - 1n : quotient;
@@ -11480,8 +11493,8 @@ function resolveLegs(legs) {
 function getCandidateStrikes(params, spacing, tickSpacing, halfWidth) {
 	const lower = MIN_TICK + halfWidth > params.currentTick - halfWidth + 1n ? MIN_TICK + halfWidth : params.currentTick - halfWidth + 1n;
 	const upper = MAX_TICK - halfWidth < params.currentTick + halfWidth - 1n ? MAX_TICK - halfWidth : params.currentTick + halfWidth - 1n;
-	const firstStrike = ceilDiv$1(lower, tickSpacing) * tickSpacing;
-	const lastStrike = floorDiv(upper, tickSpacing) * tickSpacing;
+	const firstStrike = ceilDiv$3(lower, tickSpacing) * tickSpacing;
+	const lastStrike = floorDiv$1(upper, tickSpacing) * tickSpacing;
 	const strikes = [];
 	for (let strike = firstStrike; strike <= lastStrike; strike += tickSpacing) if (isPriceGridStrike(strike, params, spacing, tickSpacing)) strikes.push(strike);
 	if (params.asset === 1n) strikes.reverse();
@@ -11521,7 +11534,7 @@ function generateOverlappingTokenIds(params) {
 	if (params.currentTick < MIN_TICK || params.currentTick > MAX_TICK) invalid$1(`currentTick must be between ${MIN_TICK} and ${MAX_TICK}`);
 	if (params.asset !== 0n && params.asset !== 1n) invalid$1("asset must be 0 or 1");
 	if (params.assetDecimals < 0n || params.assetDecimals > MAX_TOKEN_DECIMALS || params.quoteDecimals < 0n || params.quoteDecimals > MAX_TOKEN_DECIMALS) invalid$1("assetDecimals and quoteDecimals must be between 0 and 255");
-	if (params.positionSize <= 0n || params.positionSize > MAX_UINT128$3) invalid$1("positionSize must be between 1 and uint128.max");
+	if (params.positionSize <= 0n || params.positionSize > MAX_UINT128$4) invalid$1("positionSize must be between 1 and uint128.max");
 	const tickSpacing = decodeTickSpacing(params.poolId);
 	if (tickSpacing <= 0n) invalid$1("poolId tick spacing must be positive");
 	const standardTickWidth = STANDARD_TICK_WIDTHS[params.timescale];
@@ -11542,15 +11555,15 @@ function generateOverlappingTokenIds(params) {
 
 //#endregion
 //#region src/panoptic/v2/tokenId/split.ts
-const POOL_ID_MASK$2 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
-const MAX_UINT128$2 = (1n << 128n) - 1n;
+const POOL_ID_MASK$3 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+const MAX_UINT128$3 = (1n << 128n) - 1n;
 const MAX_UINT256$1 = (1n << 256n) - 1n;
 function invalid(message) {
 	throw new PanopticValidationError(`splitTokenIdByTimescale: ${message}`);
 }
 function validateInput(tokenId, positionSize) {
 	if (tokenId < 0n || tokenId > MAX_UINT256$1) invalid("tokenId must fit in uint256");
-	if (positionSize <= 0n || positionSize > MAX_UINT128$2) invalid("positionSize must be between 1 and uint128.max");
+	if (positionSize <= 0n || positionSize > MAX_UINT128$3) invalid("positionSize must be between 1 and uint128.max");
 	const legs = decodeAllLegs(tokenId);
 	if (legs.length === 0) invalid("tokenId must contain at least one active leg");
 	for (const [index, leg] of legs.entries()) if (leg.index !== BigInt(index)) invalid("active legs must be contiguous from index 0");
@@ -11679,7 +11692,7 @@ function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
 	const targetTickWidth = STANDARD_TICK_WIDTHS[targetTimescale];
 	if (targetTickWidth === void 0) invalid(`unknown target timescale ${String(targetTimescale)}`);
 	const targetWidth = (targetTickWidth + tickSpacing - 1n) / tickSpacing;
-	const poolId = tokenId & POOL_ID_MASK$2;
+	const poolId = tokenId & POOL_ID_MASK$3;
 	const optionLegs = legs.filter((leg) => leg.width > 0n);
 	const fundingLegs = legs.filter((leg) => leg.width === 0n);
 	const positionIdList = [];
@@ -13562,7 +13575,7 @@ async function fetchPoolId(params) {
 //#endregion
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
-const Q96 = 1n << 96n;
+const Q96$1 = 1n << 96n;
 const Q192$2 = 1n << 192n;
 /**
 * Convert tick to quote-denominated tick based on asset direction.
@@ -13710,7 +13723,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 	const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const rX192 = sqrtR * sqrtR;
-	const sqrtKPmX96 = divTrunc(sqrtK * Q96, sqrtPm);
+	const sqrtKPmX96 = divTrunc(sqrtK * Q96$1, sqrtPm);
 	const diff = sqrtR - sqrtKPmX96;
 	const diffSqX192 = diff * diff;
 	return divTrunc(m * diffSqX192, rX192 - Q192$2);
@@ -13782,7 +13795,7 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 		const PX192 = sqrtP * sqrtP;
 		const KX192 = sqrtK * sqrtK;
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (2n * sqrtPKR * Q96 - PX192 - KX192);
+		const numerator = m * (2n * sqrtPKR * Q96$1 - PX192 - KX192);
 		const denominator = rX192 - Q192$2;
 		v = divTrunc(numerator, denominator);
 	}
@@ -13890,7 +13903,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const rX192 = sqrtR * sqrtR;
-			const sqrtKPmX96 = sqrtK * Q96 / sqrtPm;
+			const sqrtKPmX96 = sqrtK * Q96$1 / sqrtPm;
 			const diff = sqrtR - sqrtKPmX96;
 			const diffSqX192 = diff * diff;
 			return divTrunc(m * diffSqX192, rX192 - Q192$2);
@@ -13949,7 +13962,7 @@ function getLegGamma(leg, currentTick, positionSize, poolTickSpacing, assetIndex
 	const sqrtKPR = tickToSqrtPriceX96(qStrikeTick + qCurrentTick + halfWidthTick);
 	const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 	const rX192 = sqrtR * sqrtR;
-	const numerator = m * sqrtKPR * Q96;
+	const numerator = m * sqrtKPR * Q96$1;
 	const denominator = 2n * (rX192 - Q192$2);
 	return divTrunc(numerator, denominator);
 }
@@ -18070,7 +18083,7 @@ function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
 	return (estimatedAmountIn * (BPS_DENOMINATOR$3 + slippageBps) + BPS_DENOMINATOR$3 - 1n) / BPS_DENOMINATOR$3;
 }
-function ceilDiv(numerator, denominator) {
+function ceilDiv$2(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
@@ -18185,7 +18198,7 @@ async function quoteTokenShortfallRecovery(params) {
 				error: new PanopticError("Insufficient source collateral for the recovery swap")
 			};
 			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
+				creditInput = estimatedAmountOut > 0n ? ceilDiv$2(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
 				continue;
 			}
 			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
@@ -18239,7 +18252,7 @@ async function quoteTokenShortfallRecovery(params) {
 			};
 			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+			creditInput = ceilDiv$2(creditInput * requiredOutput, estimatedAmountOut) + 1n;
 		}
 		return {
 			available: false,
@@ -18295,7 +18308,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
 		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			creditOutSize = swapOutput > 0n ? ceilDiv$2(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 			continue;
 		}
 		if (sourceBalance < maxAmountIn) return {
@@ -18354,7 +18367,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;
+		creditOutSize = swapOutput > 0n ? ceilDiv$2(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return {
 		available: false,
@@ -18703,7 +18716,7 @@ async function getItmAmounts(params) {
 */
 const FLOW_NEUTRAL_DUST_THRESHOLD = 1000n;
 const Q192$1 = 1n << 192n;
-const POOL_ID_MASK$1 = (1n << 64n) - 1n;
+const POOL_ID_MASK$2 = (1n << 64n) - 1n;
 /**
 * Floor integer square root for bigints (Newton's method). Exact for all
 * non-negative inputs — no float precision loss for values above 2^53.
@@ -18863,7 +18876,7 @@ async function createFlowNeutralTokenId(params) {
 	const measureSize = referenceSize !== void 0 && referenceSize > 0n && referenceSize < positionSize ? referenceSize : positionSize;
 	const legCount = countLegs(tokenId);
 	if (legCount >= 4n) throw new PanopticError("Cannot append neutralizing leg: tokenId already has 4 legs");
-	const poolId = tokenId & POOL_ID_MASK$1;
+	const poolId = tokenId & POOL_ID_MASK$2;
 	const baseLegs = decodeAllLegs(tokenId);
 	const prependNeutral = baseLegs.length === 1 && baseLegs[0].tokenType === baseLegs[0].asset;
 	let credit;
@@ -19170,7 +19183,7 @@ async function tryWithdrawSimulation(params) {
 //#endregion
 //#region src/panoptic/v2/reads/collateralBreakdown.ts
 /** Mask selecting the poolId (low 64 bits) of a tokenId. */
-const POOL_ID_MASK = (1n << 64n) - 1n;
+const POOL_ID_MASK$1 = (1n << 64n) - 1n;
 /** `getRequiredBase` prices at `type(uint64).max`; results scale linearly in size. */
 const MAX_UINT64 = 2n ** 64n - 1n;
 /** Kinds whose collateral rule is identical on-chain and must share one explanation. */
@@ -19295,7 +19308,7 @@ function isolateGroupTokenId(tokenId, legIndices) {
 	const byIndex = new Map(legs.map((leg) => [leg.index, leg]));
 	const ordered = [...legIndices].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
 	const remapped = new Map(ordered.map((old, i) => [old, BigInt(i)]));
-	let out = tokenId & POOL_ID_MASK;
+	let out = tokenId & POOL_ID_MASK$1;
 	for (const [index, oldIndex] of ordered.entries()) {
 		const leg = byIndex.get(oldIndex);
 		if (leg === void 0) throw new PanopticError(`isolateGroupTokenId: leg ${oldIndex} is not present in the tokenId`);
@@ -22166,7 +22179,7 @@ const nfpmAbi = [{
 	}],
 	stateMutability: "payable"
 }];
-const MAX_UINT128$1 = 2n ** 128n - 1n;
+const MAX_UINT128$2 = 2n ** 128n - 1n;
 const MAX_UINT256 = 2n ** 256n - 1n;
 const Q128 = 2n ** 128n;
 /**
@@ -22208,8 +22221,8 @@ async function getUniswapV3LpPositionState(params) {
 			args: [{
 				tokenId,
 				recipient: owner,
-				amount0Max: MAX_UINT128$1,
-				amount1Max: MAX_UINT128$1
+				amount0Max: MAX_UINT128$2,
+				amount1Max: MAX_UINT128$2
 			}],
 			account: owner,
 			blockNumber: _meta.blockNumber
@@ -24586,214 +24599,864 @@ async function executeSettleSequenceAndWait(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/writes/settle.ts
-/**
-* Settle accumulated premia on existing positions.
-*
-* This function triggers premium collection without changing position size.
-* It calls dispatch with unchanged position lists.
-*
-* @param params - Settlement parameters
-* @returns TxResult
-*
-* @example
-* ```typescript
-* const result = await settleAccumulatedPremia({
-*   client,
-*   walletClient,
-*   account,
-*   poolAddress,
-*   positionIdList: existingPositions,
-* })
-* const receipt = await result.wait()
-* ```
-*/
-async function settleAccumulatedPremia(params) {
-	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
+//#region src/panoptic/v2/writes/protectedSettle.ts
+const POOL_ID_MASK = (1n << 64n) - 1n;
+const Q96 = 1n << 96n;
+const MAX_UINT128$1 = (1n << 128n) - 1n;
+const SETTLE_LIMITS = [
+	-887272n,
+	887272n,
+	0n
+];
+function ceilDiv$1(numerator, denominator) {
+	return (numerator + denominator - 1n) / denominator;
+}
+/** Smallest position size that creates non-zero liquidity on every poke leg. */
+function minimumPokeSize(legs, tickSpacing) {
+	let requiredSize = 1n;
+	for (const leg of legs) {
+		const widthInTicks = leg.width * tickSpacing;
+		const lowerTick = leg.strike - widthInTicks / 2n;
+		const upperTick = leg.strike + (widthInTicks + 1n) / 2n;
+		const sqrtLower = tickToSqrtPriceX96(lowerTick);
+		const sqrtUpper = tickToSqrtPriceX96(upperTick);
+		const delta = sqrtUpper - sqrtLower;
+		const liquidityFactor = leg.asset === 0n ? sqrtLower * sqrtUpper / Q96 : Q96;
+		if (liquidityFactor === 0n) return void 0;
+		const requiredAmount = ceilDiv$1(delta, liquidityFactor);
+		const legSize = ceilDiv$1(requiredAmount, leg.optionRatio);
+		if (legSize > requiredSize) requiredSize = legSize;
+	}
+	if (requiredSize > MAX_UINT128$1) return void 0;
+	return requiredSize;
+}
+function encodePokeToken(sourceTokenId, legs, firstRatio, assetMask) {
+	let tokenId = sourceTokenId & POOL_ID_MASK;
+	legs.forEach((leg, index) => {
+		const encodedIndex = BigInt(index);
+		tokenId = addLegToTokenId(tokenId, {
+			index: encodedIndex,
+			asset: assetMask >> encodedIndex & 1n,
+			optionRatio: index === 0 ? firstRatio : leg.optionRatio,
+			isLong: 0n,
+			tokenType: leg.tokenType,
+			riskPartner: encodedIndex,
+			strike: leg.strike,
+			width: leg.width
+		});
 	});
-	const tickAndSpreadLimits = positionIdList.map(() => [
-		-887272n,
-		887272n,
-		0n
-	]);
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "dispatch",
-		args: [
-			positionIdList,
-			finalPositionIdList ?? positionIdList,
-			positionSizes.map((s) => BigInt(s)),
-			tickAndSpreadLimits.map((t) => [
-				Number(t[0]),
-				Number(t[1]),
-				Number(t[2])
-			]),
-			usePremiaAsCollateral,
-			builderCode
-		],
-		txOverrides
+	return tokenId;
+}
+function buildUniquePoke(sourceTokenId, occupied) {
+	const seenChunks = new Set();
+	const shortChunkLegs = decodeAllLegs(sourceTokenId).filter((leg) => {
+		if (leg.isLong || leg.width === 0n) return false;
+		const chunkKey = `${leg.strike}:${leg.width}:${leg.tokenType}`;
+		if (seenChunks.has(chunkKey)) return false;
+		seenChunks.add(chunkKey);
+		return true;
 	});
-}
-/**
-* Settle premia and wait for confirmation.
-*/
-async function settleAccumulatedPremiaAndWait(params) {
-	const result = await settleAccumulatedPremia(params);
-	return result.wait();
-}
-
-//#endregion
-//#region src/panoptic/v2/writes/pokeOracle.ts
-/**
-* Poke the oracle to update its state.
-*
-* This function can be called to advance the oracle epoch.
-* Note: The oracle can only be poked once per epoch (64 seconds).
-*
-* @param params - Poke oracle parameters
-* @returns TxResult
-* @throws OracleRateLimitedError if checkRateLimit is true and oracle was recently poked
-*
-* @example
-* ```typescript
-* const result = await pokeOracle({
-*   client,
-*   walletClient,
-*   account,
-*   poolAddress,
-* })
-* const receipt = await result.wait()
-* ```
-*/
-async function pokeOracle(params) {
-	const { client, walletClient, account, poolAddress, checkRateLimit = false, txOverrides } = params;
-	if (checkRateLimit) {
-		const [oracleData, block] = await Promise.all([client.readContract({
-			address: poolAddress,
-			abi: panopticPoolV2Abi,
-			functionName: "getOracleTicks"
-		}), client.getBlock()]);
-		const oraclePack = oracleData[4];
-		const { epoch } = decodeOracleTiming(oraclePack, block.timestamp);
-		const currentEpoch = oracleEpochAt(block.timestamp);
-		if (currentEpoch === epoch) {
-			const lastUpdate = epoch << 6n;
-			throw new OracleRateLimitedError(lastUpdate, block.timestamp);
+	if (shortChunkLegs.length === 0) return void 0;
+	const originalRatio = shortChunkLegs[0].optionRatio;
+	for (let ratioOffset = 0n; ratioOffset < 127n; ratioOffset += 1n) {
+		const firstRatio = (originalRatio - 1n + ratioOffset) % 127n + 1n;
+		const assetVariants = 1n << BigInt(shortChunkLegs.length);
+		for (let assetMask = 0n; assetMask < assetVariants; assetMask += 1n) {
+			const tokenId = encodePokeToken(sourceTokenId, shortChunkLegs, firstRatio, assetMask);
+			if (!occupied.has(tokenId)) {
+				const size = minimumPokeSize(decodeAllLegs(tokenId), decodeTickSpacing(sourceTokenId));
+				if (size !== void 0) return {
+					tokenId,
+					size
+				};
+			}
 		}
 	}
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "pokeOracle",
-		args: [],
-		txOverrides
+	throw new PanopticError("Unable to derive a collision-free protected settlement poke");
+}
+/**
+* Build `[poke, settle, poke]` for every target containing a width>0 short.
+* Pure-long and width-zero positions are settled directly.
+*/
+function buildProtectedSettlePlan(params) {
+	const { positionIdList, finalPositionIdList, positionSizes, usePremiaAsCollateral = false, builderCode = 0n } = params;
+	if (positionIdList.length !== positionSizes.length) throw new PanopticError("Protected settlement: positionSizes length must match positionIdList");
+	const occupied = new Set(finalPositionIdList);
+	const actionIds = [];
+	const actionSizes = [];
+	const actionLimits = [];
+	const collectionIds = [];
+	const collectionSizes = [];
+	const collectionLimits = [];
+	const pokingTokenIds = [];
+	positionIdList.forEach((tokenId, index) => {
+		const poke = buildUniquePoke(tokenId, occupied);
+		if (poke === void 0) {
+			actionIds.push(tokenId);
+			actionSizes.push(positionSizes[index]);
+			actionLimits.push(SETTLE_LIMITS);
+			return;
+		}
+		occupied.add(poke.tokenId);
+		pokingTokenIds.push(poke.tokenId);
+		actionIds.push(poke.tokenId, tokenId, poke.tokenId);
+		actionSizes.push(poke.size, positionSizes[index], 0n);
+		actionLimits.push(SETTLE_LIMITS, SETTLE_LIMITS, SETTLE_LIMITS);
+		collectionIds.push(poke.tokenId, poke.tokenId);
+		collectionSizes.push(poke.size, 0n);
+		collectionLimits.push(SETTLE_LIMITS, SETTLE_LIMITS);
 	});
+	const base = {
+		finalPositionIdList: [...finalPositionIdList],
+		usePremiaAsCollateral,
+		builderCode
+	};
+	return {
+		dispatch: {
+			...base,
+			positionIdList: actionIds,
+			positionSizes: actionSizes,
+			tickAndSpreadLimits: actionLimits
+		},
+		collectionDispatch: collectionIds.length === 0 ? void 0 : {
+			...base,
+			positionIdList: collectionIds,
+			positionSizes: collectionSizes,
+			tickAndSpreadLimits: collectionLimits
+		},
+		pokingTokenIds
+	};
 }
 /**
-* Poke oracle and wait for confirmation.
+* Build the atomic self-settlement dispatch that temporarily pokes each
+* affected short chunk before settling its source position.
+*
+* @param params - Positions, current sizes, and complete held-position list.
+* @returns A dispatch intent ready for simulation or submission.
 */
-async function pokeOracleAndWait(params) {
-	const result = await pokeOracle(params);
-	return result.wait();
+function buildProtectedSettleDispatch(params) {
+	return buildProtectedSettlePlan(params).dispatch;
 }
 
 //#endregion
-//#region src/panoptic/v2/writes/factory.ts
+//#region src/panoptic/v2/simulations/simulateSettlePremiumFrom.ts
+/** Soft-failure revert markers for settle premium (target-state issues, not caller errors). */
+const SOFT_FAILURES = [
+	{
+		marker: "AccountInsolvent",
+		reason: "Target account is insolvent; premium cannot be settled"
+	},
+	{
+		marker: "PositionNotOwned",
+		reason: "Target account no longer owns the position"
+	},
+	{
+		marker: "StaleOracle",
+		reason: "Oracle price is stale; settlement temporarily unavailable"
+	},
+	{
+		marker: "InputListFail",
+		reason: "Position list is stale (target positions changed)"
+	}
+];
 /**
-* Deploy a new Panoptic pool via the factory.
+* Simulate settling another account's accumulated long premium via `dispatchFrom`
+* (equal-length `positionIdListTo`/`positionIdListToFinal` selects the settle mode).
 *
-* @param params - Deployment parameters (versioned: 'v3' or 'v4')
-* @returns Transaction result with hash and wait function
+* The measured token flow is the CALLER's collateral delta — i.e. the premium
+* the caller receives from the settlement (for chunks they sold).
+*
+* @param params - Simulation parameters
+* @returns Simulation result with settled premium data or error
 */
-async function deployNewPool(params) {
-	const { client, walletClient, account, factoryAddress, riskEngine, salt, txOverrides } = params;
-	if (params.version === "v3") return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: factoryAddress,
-		abi: panopticFactoryV3Abi,
-		functionName: "deployNewPool",
-		args: [
-			params.token0,
-			params.token1,
-			params.fee,
-			riskEngine,
-			salt
-		],
-		txOverrides
-	});
-	return submitWrite({
+async function simulateSettlePremiumFrom(params) {
+	const { client, poolAddress, account, user, positionIdListFrom, positionIdList, tokenId, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const metaPromise = getBlockMeta({
 		client,
-		walletClient,
-		account,
-		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
-		],
-		txOverrides
+		blockNumber: targetBlockNumber
 	});
-}
-/**
-* Deploy a new Panoptic pool and wait for confirmation.
-*/
-async function deployNewPoolAndWait(params) {
-	const result = await deployNewPool(params);
-	return result.wait();
-}
-
-//#endregion
-//#region src/panoptic/v2/writes/txManagement.ts
-/** Default gas price multiplier for replacement (12.5% bump = minimum for replacement) */
-const DEFAULT_GAS_PRICE_MULTIPLIER = 1.125;
-/**
-* Apply a multiplier to a bigint gas value.
-* Uses integer arithmetic to avoid floating point issues.
-*/
-function applyMultiplier(value, multiplier) {
-	const bps = BigInt(Math.ceil(multiplier * 1e4));
-	return value * bps / 10000n;
-}
-/**
-* Compute bumped gas parameters from the original transaction.
-*/
-function computeBumpedGas(originalMaxFeePerGas, originalMaxPriorityFeePerGas, explicitMaxFeePerGas, explicitMaxPriorityFeePerGas, multiplier) {
-	const maxFeePerGas = explicitMaxFeePerGas ?? applyMultiplier(originalMaxFeePerGas ?? 0n, multiplier);
-	const maxPriorityFeePerGas = explicitMaxPriorityFeePerGas ?? applyMultiplier(originalMaxPriorityFeePerGas ?? 0n, multiplier);
-	return {
-		maxFeePerGas,
-		maxPriorityFeePerGas
-	};
-}
-/**
-* Speed up a pending transaction by resubmitting with higher gas.
-*
-* Fetches the original transaction, extracts its parameters,
-* bumps the gas price, and resubmits with the same nonce.
-*
+	const emptyTokenFlow = {
+		delta0: 0n,
+		delta1: 0n,
+		balanceBefore0: 0n,
+		balanceBefore1: 0n,
+		balanceAfter0: 0n,
+		balanceAfter1: 0n,
+		tickBefore: null,
+		tickAfter: null
+	};
+	const softFailure = (errorMessage) => {
+		const match = SOFT_FAILURES.find(({ marker }) => errorMessage.includes(marker));
+		return match ? {
+			premium0: 0n,
+			premium1: 0n,
+			settled0: 0n,
+			settled1: 0n,
+			canSettle: false,
+			reason: match.reason
+		} : null;
+	};
+	try {
+		const orderedList = tokenId !== void 0 ? orderListForSettle(positionIdList, tokenId) : positionIdList;
+		const callData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "dispatchFrom",
+			args: [
+				positionIdListFrom,
+				user,
+				orderedList,
+				orderedList,
+				0n
+			]
+		});
+		const availablePremiumCallData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				false,
+				positionIdListFrom
+			]
+		});
+		const buyerOwedCallData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				user,
+				true,
+				orderedList
+			]
+		});
+		const flowResult = await simulateWithTokenFlow({
+			client,
+			poolAddress,
+			user: account,
+			callData,
+			blockNumber: targetBlockNumber,
+			preCallData: [availablePremiumCallData, buyerOwedCallData],
+			postCallData: [availablePremiumCallData, buyerOwedCallData]
+		});
+		if (!flowResult.success || !flowResult.tokenFlow) {
+			const errorMessage = flowResult.error || "Simulation failed";
+			const soft = softFailure(errorMessage);
+			if (soft) {
+				const _meta$1 = await metaPromise;
+				return {
+					success: true,
+					data: soft,
+					gasEstimate: 0n,
+					tokenFlow: emptyTokenFlow,
+					_meta: _meta$1
+				};
+			}
+			throw new PanopticError(errorMessage);
+		}
+		const _meta = await metaPromise;
+		const tokenFlow = flowResult.tokenFlow;
+		const decodePremia = (raw) => {
+			const [shortPremiumPacked, longPremiumPacked] = decodeFunctionResult({
+				abi: panopticPoolV2Abi,
+				functionName: "getFullPositionsData",
+				data: raw
+			});
+			const short = decodeLeftRightUnsigned(shortPremiumPacked);
+			const long = decodeLeftRightUnsigned(longPremiumPacked);
+			return {
+				short0: short.right,
+				short1: short.left,
+				long0: long.right,
+				long1: long.left
+			};
+		};
+		let premium0 = 0n;
+		let premium1 = 0n;
+		const preRaw = flowResult.preCallResults?.[0];
+		const postRaw = flowResult.postCallResults?.[0];
+		if (preRaw !== void 0 && postRaw !== void 0) {
+			const pre = decodePremia(preRaw);
+			const post = decodePremia(postRaw);
+			premium0 = post.short0 > pre.short0 ? post.short0 - pre.short0 : 0n;
+			premium1 = post.short1 > pre.short1 ? post.short1 - pre.short1 : 0n;
+		}
+		let settled0 = 0n;
+		let settled1 = 0n;
+		const preBuyerRaw = flowResult.preCallResults?.[1];
+		const postBuyerRaw = flowResult.postCallResults?.[1];
+		if (preBuyerRaw !== void 0 && postBuyerRaw !== void 0) {
+			const pre = decodePremia(preBuyerRaw);
+			const post = decodePremia(postBuyerRaw);
+			settled0 = pre.long0 > post.long0 ? pre.long0 - post.long0 : 0n;
+			settled1 = pre.long1 > post.long1 ? pre.long1 - post.long1 : 0n;
+		}
+		const data = {
+			premium0,
+			premium1,
+			settled0,
+			settled1,
+			canSettle: true
+		};
+		return {
+			success: true,
+			data,
+			gasEstimate: flowResult.gasEstimate,
+			tokenFlow,
+			_meta
+		};
+	} catch (error) {
+		const _meta = await metaPromise;
+		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
+		const soft = softFailure(errorMessage);
+		if (soft) return {
+			success: true,
+			data: soft,
+			gasEstimate: 0n,
+			tokenFlow: emptyTokenFlow,
+			_meta
+		};
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
+			_meta
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/simulations/simulateSettlePremiumBatch.ts
+/**
+* Simulate settling each target buyer's owed long premium, all at one block.
+*
+* Individual failures (insolvent buyer, stale list, …) are soft: the target
+* lands in the unsettleable partition instead of failing the batch. Only
+* unexpected errors reject.
+*
+* @param params - Simulation parameters
+* @returns Partitioned targets with per-target premium and totals
+*/
+async function simulateSettlePremiumBatch(params) {
+	const { client, poolAddress, account, positionIdListFrom, targets, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const metaPromise = getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	});
+	const simulations = await Promise.all(targets.map((target) => simulateSettlePremiumFrom({
+		client,
+		poolAddress,
+		account,
+		user: target.user,
+		positionIdListFrom,
+		positionIdList: target.positionIdList,
+		tokenId: target.tokenId,
+		blockNumber: targetBlockNumber
+	})));
+	const results = [];
+	const settleable = [];
+	let unsettleableCount = 0;
+	let premium0 = 0n;
+	let premium1 = 0n;
+	simulations.forEach((sim, i) => {
+		const simulation = sim.success ? sim.data : {
+			premium0: 0n,
+			premium1: 0n,
+			settled0: 0n,
+			settled1: 0n,
+			canSettle: false,
+			reason: sim.error.message
+		};
+		results.push({
+			target: targets[i],
+			simulation
+		});
+		if (simulation.canSettle) {
+			settleable.push(targets[i]);
+			premium0 += simulation.premium0;
+			premium1 += simulation.premium1;
+		} else unsettleableCount += 1;
+	});
+	const _meta = await metaPromise;
+	return {
+		results,
+		settleable,
+		unsettleableCount,
+		premium0,
+		premium1,
+		_meta
+	};
+}
+/**
+* Simulate a full settle sequence (all settles + optional close) as the one
+* multicall that `executeSettleSequence` submits, measuring the caller's
+* total token flow and gas.
+*
+* @param params - Simulation parameters
+* @returns Simulation result with the caller's net flow, or error
+*/
+async function simulateSettleSequence(params) {
+	const { client, poolAddress, account, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const metaPromise = getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	});
+	try {
+		const calls = buildSettleSequenceCalls(params);
+		const callData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "multicall",
+			args: [calls]
+		});
+		const flowResult = await simulateWithTokenFlow({
+			client,
+			poolAddress,
+			user: account,
+			callData,
+			blockNumber: targetBlockNumber
+		});
+		if (!flowResult.success || !flowResult.tokenFlow) throw new PanopticError(flowResult.error || "Simulation failed");
+		const _meta = await metaPromise;
+		const tokenFlow = flowResult.tokenFlow;
+		return {
+			success: true,
+			data: {
+				delta0: tokenFlow.delta0,
+				delta1: tokenFlow.delta1
+			},
+			gasEstimate: flowResult.gasEstimate,
+			tokenFlow,
+			_meta
+		};
+	} catch (error) {
+		const _meta = await metaPromise;
+		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
+			_meta
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/simulations/simulateSettle.ts
+const BIT_MASK_128 = (1n << 128n) - 1n;
+const multicallAbi = [{
+	type: "function",
+	name: "multicall",
+	inputs: [{
+		name: "data",
+		type: "bytes[]"
+	}],
+	outputs: [{
+		name: "results",
+		type: "bytes[]"
+	}],
+	stateMutability: "nonpayable"
+}];
+function encodeDispatch(plan) {
+	const dispatch$1 = plan.dispatch;
+	return encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "dispatch",
+		args: [
+			dispatch$1.positionIdList,
+			dispatch$1.finalPositionIdList,
+			dispatch$1.positionSizes,
+			dispatch$1.tickAndSpreadLimits.map((limits) => [
+				Number(limits[0]),
+				Number(limits[1]),
+				Number(limits[2])
+			]),
+			dispatch$1.usePremiaAsCollateral,
+			dispatch$1.builderCode
+		]
+	});
+}
+function decodeShortPremium(data) {
+	const packed = decodeFunctionResult({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		data
+	})[0];
+	return [packed & BIT_MASK_128, packed >> 128n];
+}
+async function remainingForfeitAfterProtection(params) {
+	const { client, poolAddress, account, positionIdList, targets, plan, blockNumber, initial } = params;
+	if (targets.length === 0 && plan.collectionDispatch === void 0) return [...initial];
+	const protectionCalls = buildSettleSequenceCalls({
+		positionIdListFrom: params.finalPositionIdList,
+		targets,
+		dispatch: plan.collectionDispatch
+	});
+	const availableCall = encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			false,
+			positionIdList
+		]
+	});
+	const totalCall = encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			true,
+			positionIdList
+		]
+	});
+	const { result } = await client.simulateContract({
+		address: poolAddress,
+		abi: multicallAbi,
+		functionName: "multicall",
+		args: [[
+			...protectionCalls,
+			availableCall,
+			totalCall
+		]],
+		account,
+		blockNumber
+	});
+	const available = decodeShortPremium(result[result.length - 2]);
+	const total = decodeShortPremium(result[result.length - 1]);
+	return [total[0] > available[0] ? total[0] - available[0] : 0n, total[1] > available[1] ? total[1] - available[1] : 0n];
+}
+async function simulateSettle(params) {
+	const { client, poolAddress, account, positionIdList, finalPositionIdList = positionIdList, positionSizes: providedSizes, targets = [], usePremiaAsCollateral = false, builderCode = 0n, allowForfeit = false, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const metaPromise = getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	});
+	try {
+		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 plan = buildProtectedSettlePlan({
+			positionIdList,
+			finalPositionIdList,
+			positionSizes,
+			usePremiaAsCollateral,
+			builderCode
+		});
+		const initialForfeit = await getForfeitablePremium({
+			client,
+			poolAddress,
+			account,
+			tokenIds: positionIdList,
+			blockNumber: targetBlockNumber
+		});
+		const initial = [initialForfeit.forfeit0, initialForfeit.forfeit1];
+		if (targets.length > 0) {
+			const buyers = await simulateSettlePremiumBatch({
+				client,
+				poolAddress,
+				account,
+				positionIdListFrom: finalPositionIdList,
+				targets,
+				blockNumber: targetBlockNumber
+			});
+			if (buyers.unsettleableCount > 0) throw new UnsafePremiumSettlementError(initial, buyers.unsettleableCount);
+		}
+		const remainingForfeit = await remainingForfeitAfterProtection({
+			client,
+			poolAddress,
+			account,
+			positionIdList,
+			finalPositionIdList,
+			targets,
+			plan,
+			blockNumber: targetBlockNumber,
+			initial
+		});
+		if ((remainingForfeit[0] > 0n || remainingForfeit[1] > 0n) && !allowForfeit) throw new UnsafePremiumSettlementError(remainingForfeit, 0);
+		const callData = targets.length === 0 ? encodeDispatch(plan) : encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "multicall",
+			args: [buildSettleSequenceCalls({
+				positionIdListFrom: finalPositionIdList,
+				targets,
+				dispatch: plan.dispatch
+			})]
+		});
+		const flowResult = await simulateWithTokenFlow({
+			client,
+			poolAddress,
+			user: account,
+			callData,
+			blockNumber: targetBlockNumber
+		});
+		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Simulation failed");
+		const tokenFlow = flowResult.tokenFlow;
+		return {
+			success: true,
+			data: {
+				premiaReceived0: tokenFlow.delta0,
+				premiaReceived1: tokenFlow.delta1,
+				postCollateral0: tokenFlow.balanceAfter0,
+				postCollateral1: tokenFlow.balanceAfter1,
+				premiumProtected: [initial[0] - remainingForfeit[0], initial[1] - remainingForfeit[1]],
+				remainingForfeit,
+				usesPoke: plan.pokingTokenIds.length > 0,
+				settledBuyerCount: targets.length
+			},
+			gasEstimate: flowResult.gasEstimate,
+			tokenFlow,
+			_meta: await metaPromise
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Simulation failed", error instanceof Error ? error : void 0),
+			_meta: await metaPromise
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/settle.ts
+/**
+* Settle accumulated premia on existing positions.
+*
+* This function triggers premium collection without changing position size.
+* It calls dispatch with unchanged position lists.
+*
+* @param params - Settlement parameters
+* @returns TxResult
+*
+* @example
+* ```typescript
+* const result = await settleAccumulatedPremia({
+*   client,
+*   walletClient,
+*   account,
+*   poolAddress,
+*   positionIdList: existingPositions,
+* })
+* const receipt = await result.wait()
+* ```
+*/
+async function settleAccumulatedPremia(params) {
+	const { client, walletClient, account, poolAddress, positionIdList, finalPositionIdList, positionSizes: providedSizes, targets = [], skipPreflight = false, allowForfeit = false, 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 heldPositions = finalPositionIdList ?? positionIdList;
+	if (!skipPreflight) {
+		const simulation = await simulateSettle({
+			client,
+			poolAddress,
+			account,
+			positionIdList,
+			finalPositionIdList: heldPositions,
+			positionSizes,
+			targets,
+			usePremiaAsCollateral,
+			builderCode,
+			allowForfeit
+		});
+		if (!simulation.success) throw simulation.error;
+	}
+	const { dispatch: dispatch$1 } = buildProtectedSettlePlan({
+		positionIdList,
+		finalPositionIdList: heldPositions,
+		positionSizes,
+		usePremiaAsCollateral,
+		builderCode
+	});
+	if (targets.length > 0) return executeSettleSequence({
+		client,
+		walletClient,
+		account,
+		poolAddress,
+		positionIdListFrom: heldPositions,
+		targets,
+		dispatch: dispatch$1,
+		txOverrides
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "dispatch",
+		args: [
+			dispatch$1.positionIdList,
+			dispatch$1.finalPositionIdList,
+			dispatch$1.positionSizes,
+			dispatch$1.tickAndSpreadLimits.map((t) => [
+				Number(t[0]),
+				Number(t[1]),
+				Number(t[2])
+			]),
+			dispatch$1.usePremiaAsCollateral,
+			dispatch$1.builderCode
+		],
+		txOverrides
+	});
+}
+/**
+* Settle premia and wait for confirmation.
+*/
+async function settleAccumulatedPremiaAndWait(params) {
+	const result = await settleAccumulatedPremia(params);
+	return result.wait();
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/pokeOracle.ts
+/**
+* Poke the oracle to update its state.
+*
+* This function can be called to advance the oracle epoch.
+* Note: The oracle can only be poked once per epoch (64 seconds).
+*
+* @param params - Poke oracle parameters
+* @returns TxResult
+* @throws OracleRateLimitedError if checkRateLimit is true and oracle was recently poked
+*
+* @example
+* ```typescript
+* const result = await pokeOracle({
+*   client,
+*   walletClient,
+*   account,
+*   poolAddress,
+* })
+* const receipt = await result.wait()
+* ```
+*/
+async function pokeOracle(params) {
+	const { client, walletClient, account, poolAddress, checkRateLimit = false, txOverrides } = params;
+	if (checkRateLimit) {
+		const [oracleData, block] = await Promise.all([client.readContract({
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "getOracleTicks"
+		}), client.getBlock()]);
+		const oraclePack = oracleData[4];
+		const { epoch } = decodeOracleTiming(oraclePack, block.timestamp);
+		const currentEpoch = oracleEpochAt(block.timestamp);
+		if (currentEpoch === epoch) {
+			const lastUpdate = epoch << 6n;
+			throw new OracleRateLimitedError(lastUpdate, block.timestamp);
+		}
+	}
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "pokeOracle",
+		args: [],
+		txOverrides
+	});
+}
+/**
+* Poke oracle and wait for confirmation.
+*/
+async function pokeOracleAndWait(params) {
+	const result = await pokeOracle(params);
+	return result.wait();
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/factory.ts
+/**
+* Deploy a new Panoptic pool via the factory.
+*
+* @param params - Deployment parameters (versioned: 'v3' or 'v4')
+* @returns Transaction result with hash and wait function
+*/
+async function deployNewPool(params) {
+	const { client, walletClient, account, factoryAddress, riskEngine, salt, txOverrides } = params;
+	if (params.version === "v3") return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: factoryAddress,
+		abi: panopticFactoryV3Abi,
+		functionName: "deployNewPool",
+		args: [
+			params.token0,
+			params.token1,
+			params.fee,
+			riskEngine,
+			salt
+		],
+		txOverrides
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		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
+		],
+		txOverrides
+	});
+}
+/**
+* Deploy a new Panoptic pool and wait for confirmation.
+*/
+async function deployNewPoolAndWait(params) {
+	const result = await deployNewPool(params);
+	return result.wait();
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/txManagement.ts
+/** Default gas price multiplier for replacement (12.5% bump = minimum for replacement) */
+const DEFAULT_GAS_PRICE_MULTIPLIER = 1.125;
+/**
+* Apply a multiplier to a bigint gas value.
+* Uses integer arithmetic to avoid floating point issues.
+*/
+function applyMultiplier(value, multiplier) {
+	const bps = BigInt(Math.ceil(multiplier * 1e4));
+	return value * bps / 10000n;
+}
+/**
+* Compute bumped gas parameters from the original transaction.
+*/
+function computeBumpedGas(originalMaxFeePerGas, originalMaxPriorityFeePerGas, explicitMaxFeePerGas, explicitMaxPriorityFeePerGas, multiplier) {
+	const maxFeePerGas = explicitMaxFeePerGas ?? applyMultiplier(originalMaxFeePerGas ?? 0n, multiplier);
+	const maxPriorityFeePerGas = explicitMaxPriorityFeePerGas ?? applyMultiplier(originalMaxPriorityFeePerGas ?? 0n, multiplier);
+	return {
+		maxFeePerGas,
+		maxPriorityFeePerGas
+	};
+}
+/**
+* Speed up a pending transaction by resubmitting with higher gas.
+*
+* Fetches the original transaction, extracts its parameters,
+* bumps the gas price, and resubmits with the same nonce.
+*
 * @param params - Speed up parameters
 * @returns TxResult for the replacement transaction
 * @throws Error if the original transaction is not found
@@ -25783,469 +26446,145 @@ async function smartRepay(params) {
 				client,
 				walletClient,
 				account,
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "dispatch",
-				args: [
-					opsPositionIds,
-					finalPositionIdList,
-					opsSizes,
-					opsLimits,
-					false,
-					builderCode
-				],
-				txOverrides
-			});
-		} catch (error) {
-			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
-			throw error;
-		}
-	}
-	throw new MaxRetriesExceededError("smartRepay");
-}
-/**
-* Smart repay and wait for confirmation.
-*/
-async function smartRepayAndWait(params) {
-	const result = await smartRepay(params);
-	const receipt = await result.wait();
-	if (params.storage && params.chainId !== void 0) {
-		const { client, account, poolAddress, chainId, token, amount, storage, existingPositionIds } = params;
-		const pool = await getPool({
-			client,
-			poolAddress,
-			chainId
-		});
-		const tokenIndex = resolveTokenIndex(token, pool.collateralTracker0.token, pool.collateralTracker1.token);
-		const loans = await getLoanPositionsForToken(client, poolAddress, account, existingPositionIds, tokenIndex);
-		const loanIds = loans.map((l) => l.tokenId);
-		const totalDebt = loans.reduce((sum, l) => sum + l.tokenAmount, 0n);
-		const remainder = totalDebt > amount ? totalDebt - amount : 0n;
-		const positionIds = existingPositionIds ?? await getTrackedPositionIds({
-			chainId,
-			poolAddress,
-			account,
-			storage
-		});
-		let updatedIds = positionIds.filter((id) => !loanIds.includes(id));
-		if (remainder > 0n) {
-			const nonLoanIds = existingPositionIds.filter((id) => !loanIds.includes(id));
-			const newLoan = buildUniqueLoan(pool.poolId, tokenIndex, tokenIndex, pool.currentTick, pool.tickSpacing, nonLoanIds, remainder);
-			updatedIds = [...updatedIds, newLoan.tokenId];
-		}
-		await savePositionIds(storage, chainId, poolAddress, account, updatedIds);
-	}
-	return receipt;
-}
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateBatchDispatch.ts
-/**
-* Simulate a batch dispatch built from `items` + the current on-chain
-* positionIdList. Returns batch diagnostics OR a real simulation result.
-*/
-async function simulateBatchDispatch(params) {
-	const { client, poolAddress, account, items, existingPositionIds, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
-	const { args, diagnostics } = buildBatchDispatchArgs({
-		items,
-		existingPositionIds,
-		usePremiaAsCollateral,
-		builderCode
-	});
-	if (args === null) {
-		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-		const meta = await getBlockMeta({
-			client,
-			blockNumber: targetBlockNumber
-		});
-		return {
-			success: false,
-			diagnostics,
-			_meta: meta
-		};
-	}
-	const sim = await simulateDispatch({
-		client,
-		poolAddress,
-		account,
-		positionIdList: args.positionIdList,
-		finalPositionIdList: args.finalPositionIdList,
-		existingPositionIdList: existingPositionIds,
-		positionSizes: args.positionSizes,
-		tickAndSpreadLimits: args.tickAndSpreadLimits,
-		usePremiaAsCollateral: args.usePremiaAsCollateral,
-		builderCode: args.builderCode,
-		blockNumber
-	});
-	return {
-		...sim,
-		diagnostics: []
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateClosePosition.ts
-/**
-* Simulate closing a position.
-*
-* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
-* to measure exact collateral asset movements from the burn.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with close data or error
-*/
-async function simulateClosePosition(params) {
-	const { client, poolAddress, account, positionIdList, tokenId, tickLimitLow, tickLimitHigh, spreadLimit = 0n, swapAtMint = false, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	const tickLimits$1 = swapAtMint ? [
-		Number(tickLimitHigh),
-		Number(tickLimitLow),
-		Number(spreadLimit)
-	] : [
-		Number(tickLimitLow),
-		Number(tickLimitHigh),
-		Number(spreadLimit)
-	];
-	try {
-		const finalPositionIdList = positionIdList.filter((id) => id !== tokenId);
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatch",
-			args: [
-				[tokenId],
-				finalPositionIdList,
-				[0n],
-				[tickLimits$1],
-				usePremiaAsCollateral,
-				builderCode
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
-			client,
-			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber
-		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
-		const tokenFlow = flowResult.tokenFlow;
-		const _meta = await metaPromise;
-		const data = {
-			amount0Received: tokenFlow.delta0,
-			amount1Received: tokenFlow.delta1,
-			premiaCollected0: null,
-			premiaCollected1: null,
-			postCollateral0: tokenFlow.balanceAfter0,
-			postCollateral1: tokenFlow.balanceAfter1,
-			realizedPnL0: null,
-			realizedPnL1: null
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		return {
-			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Simulation failed", error instanceof Error ? error : void 0),
-			_meta
-		};
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "dispatch",
+				args: [
+					opsPositionIds,
+					finalPositionIdList,
+					opsSizes,
+					opsLimits,
+					false,
+					builderCode
+				],
+				txOverrides
+			});
+		} catch (error) {
+			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
+			throw error;
+		}
 	}
+	throw new MaxRetriesExceededError("smartRepay");
 }
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateForceExercise.ts
 /**
-* Simulate a force exercise operation.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with exercise data or error
+* Smart repay and wait for confirmation.
 */
-async function simulateForceExercise(params) {
-	const { client, poolAddress, account, user, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	const emptyTokenFlow = {
-		delta0: 0n,
-		delta1: 0n,
-		balanceBefore0: 0n,
-		balanceBefore1: 0n,
-		balanceAfter0: 0n,
-		balanceAfter1: 0n,
-		tickBefore: null,
-		tickAfter: null
-	};
-	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatchFrom",
-			args: [
-				positionIdListFrom,
-				user,
-				positionIdListTo,
-				positionIdListToFinal,
-				0n
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
+async function smartRepayAndWait(params) {
+	const result = await smartRepay(params);
+	const receipt = await result.wait();
+	if (params.storage && params.chainId !== void 0) {
+		const { client, account, poolAddress, chainId, token, amount, storage, existingPositionIds } = params;
+		const pool = await getPool({
 			client,
 			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber
+			chainId
 		});
-		if (!flowResult.success || !flowResult.tokenFlow) {
-			const errorMessage = flowResult.error || "Simulation failed";
-			const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
-			if (isNotExercisable) {
-				const _meta$1 = await metaPromise;
-				const data$1 = {
-					exerciseFee0: 0n,
-					exerciseFee1: 0n,
-					canExercise: false,
-					reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
-				};
-				return {
-					success: true,
-					data: data$1,
-					gasEstimate: 0n,
-					tokenFlow: emptyTokenFlow,
-					_meta: _meta$1
-				};
-			}
-			throw new PanopticError(errorMessage);
-		}
-		const _meta = await metaPromise;
-		const tokenFlow = flowResult.tokenFlow;
-		const data = {
-			exerciseFee0: tokenFlow.delta0,
-			exerciseFee1: tokenFlow.delta1,
-			canExercise: true
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
-		if (isNotExercisable) {
-			const data = {
-				exerciseFee0: 0n,
-				exerciseFee1: 0n,
-				canExercise: false,
-				reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
-			};
-			return {
-				success: true,
-				data,
-				gasEstimate: 0n,
-				tokenFlow: emptyTokenFlow,
-				_meta
-			};
+		const tokenIndex = resolveTokenIndex(token, pool.collateralTracker0.token, pool.collateralTracker1.token);
+		const loans = await getLoanPositionsForToken(client, poolAddress, account, existingPositionIds, tokenIndex);
+		const loanIds = loans.map((l) => l.tokenId);
+		const totalDebt = loans.reduce((sum, l) => sum + l.tokenAmount, 0n);
+		const remainder = totalDebt > amount ? totalDebt - amount : 0n;
+		const positionIds = existingPositionIds ?? await getTrackedPositionIds({
+			chainId,
+			poolAddress,
+			account,
+			storage
+		});
+		let updatedIds = positionIds.filter((id) => !loanIds.includes(id));
+		if (remainder > 0n) {
+			const nonLoanIds = existingPositionIds.filter((id) => !loanIds.includes(id));
+			const newLoan = buildUniqueLoan(pool.poolId, tokenIndex, tokenIndex, pool.currentTick, pool.tickSpacing, nonLoanIds, remainder);
+			updatedIds = [...updatedIds, newLoan.tokenId];
 		}
-		return {
-			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
-			_meta
-		};
+		await savePositionIds(storage, chainId, poolAddress, account, updatedIds);
 	}
+	return receipt;
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateLiquidate.ts
+//#region src/panoptic/v2/simulations/simulateBatchDispatch.ts
 /**
-* Simulate a liquidation operation.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with liquidation data or error
+* Simulate a batch dispatch built from `items` + the current on-chain
+* positionIdList. Returns batch diagnostics OR a real simulation result.
 */
-async function simulateLiquidate(params) {
-	const { client, poolAddress, account, liquidatee, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
+async function simulateBatchDispatch(params) {
+	const { client, poolAddress, account, items, existingPositionIds, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
+	const { args, diagnostics } = buildBatchDispatchArgs({
+		items,
+		existingPositionIds,
+		usePremiaAsCollateral,
+		builderCode
 	});
-	const emptyTokenFlow = {
-		delta0: 0n,
-		delta1: 0n,
-		balanceBefore0: 0n,
-		balanceBefore1: 0n,
-		balanceAfter0: 0n,
-		balanceAfter1: 0n,
-		tickBefore: null,
-		tickAfter: null
-	};
-	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatchFrom",
-			args: [
-				positionIdListFrom,
-				liquidatee,
-				positionIdListTo,
-				positionIdListToFinal,
-				0n
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
-			client,
-			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber
-		});
-		if (!flowResult.success || !flowResult.tokenFlow) {
-			const errorMessage = flowResult.error || "Simulation failed";
-			const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
-			if (isNotLiquidatable) {
-				const _meta$1 = await metaPromise;
-				const data$1 = {
-					bonus0: 0n,
-					bonus1: 0n,
-					positionsClosed: [],
-					isLiquidatable: false,
-					shortfall0: 0n,
-					shortfall1: 0n
-				};
-				return {
-					success: true,
-					data: data$1,
-					gasEstimate: 0n,
-					tokenFlow: emptyTokenFlow,
-					_meta: _meta$1
-				};
-			}
-			throw new PanopticError(errorMessage);
-		}
-		const _meta = await metaPromise;
-		const tokenFlow = flowResult.tokenFlow;
-		const positionsClosed = positionIdListTo.filter((id) => !positionIdListToFinal.includes(id));
-		const data = {
-			bonus0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
-			bonus1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
-			positionsClosed,
-			isLiquidatable: true,
-			shortfall0: 0n,
-			shortfall1: 0n
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
-		if (isNotLiquidatable) {
-			const data = {
-				bonus0: 0n,
-				bonus1: 0n,
-				positionsClosed: [],
-				isLiquidatable: false,
-				shortfall0: 0n,
-				shortfall1: 0n
-			};
-			return {
-				success: true,
-				data,
-				gasEstimate: 0n,
-				tokenFlow: emptyTokenFlow,
-				_meta
-			};
-		}
+	if (args === null) {
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const meta = await getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
 		return {
 			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
-			_meta
+			diagnostics,
+			_meta: meta
 		};
 	}
+	const sim = await simulateDispatch({
+		client,
+		poolAddress,
+		account,
+		positionIdList: args.positionIdList,
+		finalPositionIdList: args.finalPositionIdList,
+		existingPositionIdList: existingPositionIds,
+		positionSizes: args.positionSizes,
+		tickAndSpreadLimits: args.tickAndSpreadLimits,
+		usePremiaAsCollateral: args.usePremiaAsCollateral,
+		builderCode: args.builderCode,
+		blockNumber
+	});
+	return {
+		...sim,
+		diagnostics: []
+	};
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettle.ts
-/** BIT_MASK_128 = (1n << 128n) - 1n */
-const BIT_MASK_128 = (1n << 128n) - 1n;
-/**
-* PanopticPool multicall ABI (inherited from Uniswap).
-*/
-const multicallAbi = [{
-	type: "function",
-	name: "multicall",
-	inputs: [{
-		name: "data",
-		type: "bytes[]"
-	}],
-	outputs: [{
-		name: "results",
-		type: "bytes[]"
-	}],
-	stateMutability: "nonpayable"
-}];
+//#region src/panoptic/v2/simulations/simulateClosePosition.ts
 /**
-* Simulate premium settlement.
+* Simulate closing a position.
 *
-* When `tokenId` is provided, the simulation also computes forfeit amounts
-* by chaining the dispatch with `getFullPositionsData` reads
-* in a single multicall.
+* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
+* to measure exact collateral asset movements from the burn.
 *
 * @param params - Simulation parameters
-* @returns Simulation result with settlement data or error
+* @returns Simulation result with close data or error
 */
-async function simulateSettle(params) {
-	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes: providedSizes, tokenId, blockNumber } = params;
+async function simulateClosePosition(params) {
+	const { client, poolAddress, account, positionIdList, tokenId, tickLimitLow, tickLimitHigh, spreadLimit = 0n, swapAtMint = false, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
+	const tickLimits$1 = swapAtMint ? [
+		Number(tickLimitHigh),
+		Number(tickLimitLow),
+		Number(spreadLimit)
+	] : [
+		Number(tickLimitLow),
+		Number(tickLimitHigh),
+		Number(spreadLimit)
+	];
 	try {
-		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,
-			0n
-		]);
+		const finalPositionIdList = positionIdList.filter((id) => id !== tokenId);
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
 			functionName: "dispatch",
 			args: [
-				positionIdList,
-				finalPositionIdList ?? positionIdList,
-				positionSizes.map((s) => BigInt(s)),
-				tickAndSpreadLimits.map((t) => [
-					Number(t[0]),
-					Number(t[1]),
-					Number(t[2])
-				]),
-				false,
-				0n
+				[tokenId],
+				finalPositionIdList,
+				[0n],
+				[tickLimits$1],
+				usePremiaAsCollateral,
+				builderCode
 			]
 		});
 		const flowResult = await simulateWithTokenFlow({
@@ -26257,23 +26596,16 @@ async function simulateSettle(params) {
 		});
 		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
 		const tokenFlow = flowResult.tokenFlow;
-		let forfeitAmounts;
-		if (tokenId !== void 0) forfeitAmounts = await computeForfeitAmounts({
-			client,
-			poolAddress,
-			account,
-			positionIdList,
-			tokenId,
-			dispatchCallData: callData,
-			blockNumber: targetBlockNumber
-		});
 		const _meta = await metaPromise;
 		const data = {
-			premiaReceived0: tokenFlow.delta0,
-			premiaReceived1: tokenFlow.delta1,
+			amount0Received: tokenFlow.delta0,
+			amount1Received: tokenFlow.delta1,
+			premiaCollected0: null,
+			premiaCollected1: null,
 			postCollateral0: tokenFlow.balanceAfter0,
 			postCollateral1: tokenFlow.balanceAfter1,
-			forfeitAmounts
+			realizedPnL0: null,
+			realizedPnL1: null
 		};
 		return {
 			success: true,
@@ -26291,95 +26623,17 @@ async function simulateSettle(params) {
 		};
 	}
 }
-/**
-* Compute forfeit amounts by chaining dispatch + getFullPositionsData
-* in a single PanopticPool.multicall.
-*/
-async function computeForfeitAmounts(params) {
-	const { client, poolAddress, account, tokenId, dispatchCallData, blockNumber } = params;
-	const feesCallAvailable = encodeFunctionData({
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			false,
-			[tokenId]
-		]
-	});
-	const feesCallTotal = encodeFunctionData({
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			true,
-			[tokenId]
-		]
-	});
-	try {
-		const { result } = await client.simulateContract({
-			address: poolAddress,
-			abi: multicallAbi,
-			functionName: "multicall",
-			args: [[
-				dispatchCallData,
-				feesCallAvailable,
-				feesCallTotal
-			]],
-			account,
-			blockNumber
-		});
-		const decodeFeesResult = (data) => {
-			return decodeFunctionResult({
-				abi: panopticPoolV2Abi,
-				functionName: "getFullPositionsData",
-				data
-			})[0];
-		};
-		const availablePremium = decodeFeesResult(result[1]);
-		const totalPremium = decodeFeesResult(result[2]);
-		const available0 = availablePremium & BIT_MASK_128;
-		const available1 = availablePremium >> 128n;
-		const total0 = totalPremium & BIT_MASK_128;
-		const total1 = totalPremium >> 128n;
-		return [total0 - available0, total1 - available1];
-	} catch (error) {
-		throw new PanopticError("Forfeit amount computation failed", error instanceof Error ? error : void 0);
-	}
-}
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettlePremiumFrom.ts
-/** Soft-failure revert markers for settle premium (target-state issues, not caller errors). */
-const SOFT_FAILURES = [
-	{
-		marker: "AccountInsolvent",
-		reason: "Target account is insolvent; premium cannot be settled"
-	},
-	{
-		marker: "PositionNotOwned",
-		reason: "Target account no longer owns the position"
-	},
-	{
-		marker: "StaleOracle",
-		reason: "Oracle price is stale; settlement temporarily unavailable"
-	},
-	{
-		marker: "InputListFail",
-		reason: "Position list is stale (target positions changed)"
-	}
-];
+//#region src/panoptic/v2/simulations/simulateForceExercise.ts
 /**
-* Simulate settling another account's accumulated long premium via `dispatchFrom`
-* (equal-length `positionIdListTo`/`positionIdListToFinal` selects the settle mode).
-*
-* The measured token flow is the CALLER's collateral delta — i.e. the premium
-* the caller receives from the settlement (for chunks they sold).
+* Simulate a force exercise operation.
 *
 * @param params - Simulation parameters
-* @returns Simulation result with settled premium data or error
+* @returns Simulation result with exercise data or error
 */
-async function simulateSettlePremiumFrom(params) {
-	const { client, poolAddress, account, user, positionIdListFrom, positionIdList, tokenId, blockNumber } = params;
+async function simulateForceExercise(params) {
+	const { client, poolAddress, account, user, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
@@ -26395,115 +26649,52 @@ async function simulateSettlePremiumFrom(params) {
 		tickBefore: null,
 		tickAfter: null
 	};
-	const softFailure = (errorMessage) => {
-		const match = SOFT_FAILURES.find(({ marker }) => errorMessage.includes(marker));
-		return match ? {
-			premium0: 0n,
-			premium1: 0n,
-			settled0: 0n,
-			settled1: 0n,
-			canSettle: false,
-			reason: match.reason
-		} : null;
-	};
 	try {
-		const orderedList = tokenId !== void 0 ? orderListForSettle(positionIdList, tokenId) : positionIdList;
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
 			functionName: "dispatchFrom",
 			args: [
 				positionIdListFrom,
 				user,
-				orderedList,
-				orderedList,
+				positionIdListTo,
+				positionIdListToFinal,
 				0n
 			]
 		});
-		const availablePremiumCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				positionIdListFrom
-			]
-		});
-		const buyerOwedCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				user,
-				true,
-				orderedList
-			]
-		});
 		const flowResult = await simulateWithTokenFlow({
 			client,
 			poolAddress,
 			user: account,
 			callData,
-			blockNumber: targetBlockNumber,
-			preCallData: [availablePremiumCallData, buyerOwedCallData],
-			postCallData: [availablePremiumCallData, buyerOwedCallData]
+			blockNumber: targetBlockNumber
 		});
 		if (!flowResult.success || !flowResult.tokenFlow) {
 			const errorMessage = flowResult.error || "Simulation failed";
-			const soft = softFailure(errorMessage);
-			if (soft) {
+			const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
+			if (isNotExercisable) {
 				const _meta$1 = await metaPromise;
+				const data$1 = {
+					exerciseFee0: 0n,
+					exerciseFee1: 0n,
+					canExercise: false,
+					reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
+				};
 				return {
 					success: true,
-					data: soft,
-					gasEstimate: 0n,
-					tokenFlow: emptyTokenFlow,
-					_meta: _meta$1
-				};
-			}
-			throw new PanopticError(errorMessage);
-		}
-		const _meta = await metaPromise;
-		const tokenFlow = flowResult.tokenFlow;
-		const decodePremia = (raw) => {
-			const [shortPremiumPacked, longPremiumPacked] = decodeFunctionResult({
-				abi: panopticPoolV2Abi,
-				functionName: "getFullPositionsData",
-				data: raw
-			});
-			const short = decodeLeftRightUnsigned(shortPremiumPacked);
-			const long = decodeLeftRightUnsigned(longPremiumPacked);
-			return {
-				short0: short.right,
-				short1: short.left,
-				long0: long.right,
-				long1: long.left
-			};
-		};
-		let premium0 = 0n;
-		let premium1 = 0n;
-		const preRaw = flowResult.preCallResults?.[0];
-		const postRaw = flowResult.postCallResults?.[0];
-		if (preRaw !== void 0 && postRaw !== void 0) {
-			const pre = decodePremia(preRaw);
-			const post = decodePremia(postRaw);
-			premium0 = post.short0 > pre.short0 ? post.short0 - pre.short0 : 0n;
-			premium1 = post.short1 > pre.short1 ? post.short1 - pre.short1 : 0n;
-		}
-		let settled0 = 0n;
-		let settled1 = 0n;
-		const preBuyerRaw = flowResult.preCallResults?.[1];
-		const postBuyerRaw = flowResult.postCallResults?.[1];
-		if (preBuyerRaw !== void 0 && postBuyerRaw !== void 0) {
-			const pre = decodePremia(preBuyerRaw);
-			const post = decodePremia(postBuyerRaw);
-			settled0 = pre.long0 > post.long0 ? pre.long0 - post.long0 : 0n;
-			settled1 = pre.long1 > post.long1 ? pre.long1 - post.long1 : 0n;
+					data: data$1,
+					gasEstimate: 0n,
+					tokenFlow: emptyTokenFlow,
+					_meta: _meta$1
+				};
+			}
+			throw new PanopticError(errorMessage);
 		}
+		const _meta = await metaPromise;
+		const tokenFlow = flowResult.tokenFlow;
 		const data = {
-			premium0,
-			premium1,
-			settled0,
-			settled1,
-			canSettle: true
+			exerciseFee0: tokenFlow.delta0,
+			exerciseFee1: tokenFlow.delta1,
+			canExercise: true
 		};
 		return {
 			success: true,
@@ -26515,14 +26706,22 @@ async function simulateSettlePremiumFrom(params) {
 	} catch (error) {
 		const _meta = await metaPromise;
 		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const soft = softFailure(errorMessage);
-		if (soft) return {
-			success: true,
-			data: soft,
-			gasEstimate: 0n,
-			tokenFlow: emptyTokenFlow,
-			_meta
-		};
+		const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
+		if (isNotExercisable) {
+			const data = {
+				exerciseFee0: 0n,
+				exerciseFee1: 0n,
+				canExercise: false,
+				reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
+			};
+			return {
+				success: true,
+				data,
+				gasEstimate: 0n,
+				tokenFlow: emptyTokenFlow,
+				_meta
+			};
+		}
 		return {
 			success: false,
 			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
@@ -26532,89 +26731,41 @@ async function simulateSettlePremiumFrom(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettlePremiumBatch.ts
+//#region src/panoptic/v2/simulations/simulateLiquidate.ts
 /**
-* Simulate settling each target buyer's owed long premium, all at one block.
-*
-* Individual failures (insolvent buyer, stale list, …) are soft: the target
-* lands in the unsettleable partition instead of failing the batch. Only
-* unexpected errors reject.
+* Simulate a liquidation operation.
 *
 * @param params - Simulation parameters
-* @returns Partitioned targets with per-target premium and totals
+* @returns Simulation result with liquidation data or error
 */
-async function simulateSettlePremiumBatch(params) {
-	const { client, poolAddress, account, positionIdListFrom, targets, blockNumber } = params;
+async function simulateLiquidate(params) {
+	const { client, poolAddress, account, liquidatee, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
-	const simulations = await Promise.all(targets.map((target) => simulateSettlePremiumFrom({
-		client,
-		poolAddress,
-		account,
-		user: target.user,
-		positionIdListFrom,
-		positionIdList: target.positionIdList,
-		tokenId: target.tokenId,
-		blockNumber: targetBlockNumber
-	})));
-	const results = [];
-	const settleable = [];
-	let unsettleableCount = 0;
-	let premium0 = 0n;
-	let premium1 = 0n;
-	simulations.forEach((sim, i) => {
-		const simulation = sim.success ? sim.data : {
-			premium0: 0n,
-			premium1: 0n,
-			settled0: 0n,
-			settled1: 0n,
-			canSettle: false,
-			reason: sim.error.message
-		};
-		results.push({
-			target: targets[i],
-			simulation
-		});
-		if (simulation.canSettle) {
-			settleable.push(targets[i]);
-			premium0 += simulation.premium0;
-			premium1 += simulation.premium1;
-		} else unsettleableCount += 1;
-	});
-	const _meta = await metaPromise;
-	return {
-		results,
-		settleable,
-		unsettleableCount,
-		premium0,
-		premium1,
-		_meta
+	const emptyTokenFlow = {
+		delta0: 0n,
+		delta1: 0n,
+		balanceBefore0: 0n,
+		balanceBefore1: 0n,
+		balanceAfter0: 0n,
+		balanceAfter1: 0n,
+		tickBefore: null,
+		tickAfter: null
 	};
-}
-/**
-* Simulate a full settle sequence (all settles + optional close) as the one
-* multicall that `executeSettleSequence` submits, measuring the caller's
-* total token flow and gas.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with the caller's net flow, or error
-*/
-async function simulateSettleSequence(params) {
-	const { client, poolAddress, account, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
 	try {
-		const calls = buildSettleSequenceCalls(params);
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
-			functionName: "multicall",
-			args: [calls]
+			functionName: "dispatchFrom",
+			args: [
+				positionIdListFrom,
+				liquidatee,
+				positionIdListTo,
+				positionIdListToFinal,
+				0n
+			]
 		});
 		const flowResult = await simulateWithTokenFlow({
 			client,
@@ -26623,15 +26774,43 @@ async function simulateSettleSequence(params) {
 			callData,
 			blockNumber: targetBlockNumber
 		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw new PanopticError(flowResult.error || "Simulation failed");
+		if (!flowResult.success || !flowResult.tokenFlow) {
+			const errorMessage = flowResult.error || "Simulation failed";
+			const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
+			if (isNotLiquidatable) {
+				const _meta$1 = await metaPromise;
+				const data$1 = {
+					bonus0: 0n,
+					bonus1: 0n,
+					positionsClosed: [],
+					isLiquidatable: false,
+					shortfall0: 0n,
+					shortfall1: 0n
+				};
+				return {
+					success: true,
+					data: data$1,
+					gasEstimate: 0n,
+					tokenFlow: emptyTokenFlow,
+					_meta: _meta$1
+				};
+			}
+			throw new PanopticError(errorMessage);
+		}
 		const _meta = await metaPromise;
 		const tokenFlow = flowResult.tokenFlow;
+		const positionsClosed = positionIdListTo.filter((id) => !positionIdListToFinal.includes(id));
+		const data = {
+			bonus0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
+			bonus1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
+			positionsClosed,
+			isLiquidatable: true,
+			shortfall0: 0n,
+			shortfall1: 0n
+		};
 		return {
 			success: true,
-			data: {
-				delta0: tokenFlow.delta0,
-				delta1: tokenFlow.delta1
-			},
+			data,
 			gasEstimate: flowResult.gasEstimate,
 			tokenFlow,
 			_meta
@@ -26639,6 +26818,24 @@ async function simulateSettleSequence(params) {
 	} catch (error) {
 		const _meta = await metaPromise;
 		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
+		const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
+		if (isNotLiquidatable) {
+			const data = {
+				bonus0: 0n,
+				bonus1: 0n,
+				positionsClosed: [],
+				isLiquidatable: false,
+				shortfall0: 0n,
+				shortfall1: 0n
+			};
+			return {
+				success: true,
+				data,
+				gasEstimate: 0n,
+				tokenFlow: emptyTokenFlow,
+				_meta
+			};
+		}
 		return {
 			success: false,
 			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
@@ -28652,6 +28849,441 @@ function createEventPoller(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/strike/ladder.ts
+/** Target number of rungs across a leg's full range (lower tick → upper tick). */
+const STRIKE_LADDER_TARGET_STRIKES = 16n;
+/** Nice increment mantissas, in tenths (1, 2.5, 5) × 10ⁿ. */
+const NICE_MANTISSAS_TENTHS = [
+	10n,
+	25n,
+	50n
+];
+/** Upper bound on rung hops when searching for a tick-changing step. */
+const MAX_STEP_ITERATIONS = 512;
+/** Decimal precision used when rendering exact tick prices as strings. */
+const PRICE_PRECISION = 30n;
+function floorDiv(a, b) {
+	const q = a / b;
+	return a % b !== 0n && a < 0n !== b < 0n ? q - 1n : q;
+}
+function floorMod(a, b) {
+	return a - floorDiv(a, b) * b;
+}
+function ceilDiv(a, b) {
+	return -floorDiv(-a, b);
+}
+/** round(a / b) to nearest, ties up. */
+function roundDiv(a, b) {
+	return floorDiv(2n * a + b, 2n * b);
+}
+function pow10(exp) {
+	let result = 1n;
+	for (let i = 0n; i < exp; i++) result *= 10n;
+	return result;
+}
+function gcd(a, b) {
+	a = a < 0n ? -a : a;
+	b = b < 0n ? -b : b;
+	while (b !== 0n) [a, b] = [b, a % b];
+	return a;
+}
+function reduce(f) {
+	const g = gcd(f.numerator, f.denominator);
+	return g <= 1n ? f : {
+		numerator: f.numerator / g,
+		denominator: f.denominator / g
+	};
+}
+function fromBigint(n) {
+	return {
+		numerator: n,
+		denominator: 1n
+	};
+}
+function mul(a, b) {
+	return reduce({
+		numerator: a.numerator * b.numerator,
+		denominator: a.denominator * b.denominator
+	});
+}
+function add(a, b) {
+	return reduce({
+		numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+		denominator: a.denominator * b.denominator
+	});
+}
+function sub(a, b) {
+	return add(a, {
+		numerator: -b.numerator,
+		denominator: b.denominator
+	});
+}
+/** -1 | 0 | 1 comparing a to b. */
+function cmp(a, b) {
+	const l = a.numerator * b.denominator;
+	const r = b.numerator * a.denominator;
+	return l === r ? 0 : l < r ? -1 : 1;
+}
+const LADDER_MIN = fromBigint(1n);
+/** Largest normalised price on the ladder. Prices above are "outside". */
+const LADDER_MAX = fromBigint(1000000n);
+function parseDecimal(value) {
+	const trimmed = value.trim();
+	const [basePart, exponentPart] = trimmed.toLowerCase().split("e");
+	const [integerStr, fractionalStr = ""] = basePart.split(".");
+	let numerator = BigInt(`${integerStr === "" ? "0" : integerStr}${fractionalStr}`);
+	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 (numerator <= 0n) throw new Error("Price must be positive");
+	return reduce({
+		numerator,
+		denominator
+	});
+}
+/** Render a positive fraction as a decimal string with trailing zeros trimmed. */
+function fractionToDecimal(f, precision) {
+	const scaled = f.numerator * pow10(precision) / f.denominator;
+	const digits = scaled.toString().padStart(Number(precision) + 1, "0");
+	const intPart = digits.slice(0, digits.length - Number(precision));
+	const fracPart = digits.slice(digits.length - Number(precision)).replace(/0+$/, "");
+	return fracPart.length === 0 ? intPart : `${intPart}.${fracPart}`;
+}
+/** 10^k as an exact fraction, k may be negative. */
+function powerOfTen(k) {
+	return k >= 0n ? fromBigint(pow10(k)) : {
+		numerator: 1n,
+		denominator: pow10(-k)
+	};
+}
+/** floor(log10(f)) for a positive fraction. */
+function floorLog10(f) {
+	let e = BigInt(f.numerator.toString().length - f.denominator.toString().length);
+	while (cmp(f, powerOfTen(e)) < 0) e -= 1n;
+	while (cmp(f, powerOfTen(e + 1n)) >= 0) e += 1n;
+	return e;
+}
+function orientTick(tick, orient) {
+	return orient.asset === 0n ? tick : -tick;
+}
+/** Exact-enough price of `tick` in the caller's orientation. */
+function tickToOrientedPrice(tick, orient) {
+	const price = tickToPriceDecimalScaled(orientTick(tick, orient), orient.assetDecimals, orient.quoteDecimals, PRICE_PRECISION);
+	return parseDecimal(price);
+}
+/** Nearest integer tick for a caller-oriented decimal price. */
+function orientedPriceToTick(price, orient) {
+	const t = priceToTick(price, orient.assetDecimals, orient.quoteDecimals);
+	return orientTick(t, orient);
+}
+/**
+* Relative rung step for a leg: `1.0001^(round(width·tickSpacing / TARGET)) − 1`.
+* Rungs scale with price (they are multiples of a price-proportional increment), so
+* spacing them by the range's TARGET-th root yields ≈TARGET rungs across the range
+* regardless of how wide it is.
+*/
+function relativeStep(width, tickSpacing) {
+	validateGeometry(width, tickSpacing);
+	const ticks = roundDiv(width * tickSpacing, STRIKE_LADDER_TARGET_STRIKES);
+	const ratio = parseDecimal(tickToPriceDecimalScaled(ticks < 1n ? 1n : ticks, 0n, 0n, PRICE_PRECISION));
+	return sub(ratio, fromBigint(1n));
+}
+/** Nice increment `m × 10ⁿ` (m ∈ {1, 2.5, 5}) with the smallest log-distance to `raw`. */
+function niceIncrement(raw) {
+	const e = floorLog10(raw);
+	const scale = (tenths) => mul(fromBigint(tenths), powerOfTen(e - 1n));
+	const candidates = [...NICE_MANTISSAS_TENTHS.map(scale), scale(100n)];
+	let lo = candidates[0] ?? powerOfTen(e);
+	for (const hi of candidates.slice(1)) {
+		if (cmp(raw, hi) < 0) return cmp(mul(raw, raw), mul(lo, hi)) <= 0 ? lo : hi;
+		lo = hi;
+	}
+	return lo;
+}
+/** Rung increment at normalised price `p` for the given relative step. */
+function incrementAt(p, rf) {
+	return niceIncrement(mul(p, rf));
+}
+/** Normalise a price to `max(p, 1/p)` and remember whether it was inverted. */
+function normalise(price) {
+	if (price.numerator >= price.denominator) return {
+		value: price,
+		reciprocal: false
+	};
+	return {
+		value: {
+			numerator: price.denominator,
+			denominator: price.numerator
+		},
+		reciprocal: true
+	};
+}
+/** Is `r` a multiple of `inc`? */
+function isMultiple(r, inc) {
+	return r.numerator * inc.denominator % (r.denominator * inc.numerator) === 0n;
+}
+/** Smallest multiple of `inc` strictly greater than `x`. */
+function ceilMultipleStrict(x, inc) {
+	const k = floorDiv(x.numerator * inc.denominator, x.denominator * inc.numerator) + 1n;
+	return mul(fromBigint(k), inc);
+}
+/** Largest multiple of `inc` strictly smaller than `x`. */
+function floorMultipleStrict(x, inc) {
+	const k = ceilDiv(x.numerator * inc.denominator, x.denominator * inc.numerator) - 1n;
+	return mul(fromBigint(k), inc);
+}
+/**
+* The rung set is `{ r : r is a multiple of incrementAt(r) }`. Because the
+* increment grows with price, a multiple of a finer increment can land inside a
+* coarser band where it is no longer a rung; these helpers push such a candidate
+* up/down until it is a multiple of its own band's increment.
+*/
+function isRung(r, rf) {
+	return r.numerator > 0n && isMultiple(r, incrementAt(r, rf));
+}
+function fixUp(c, rf) {
+	for (let i = 0; i < 64 && !isRung(c, rf); i++) c = ceilMultipleStrict(c, incrementAt(c, rf));
+	return c;
+}
+function fixDown(c, rf) {
+	for (let i = 0; i < 64 && c.numerator > 0n && !isRung(c, rf); i++) c = floorMultipleStrict(c, incrementAt(c, rf));
+	return c;
+}
+/** Smallest rung strictly above `x` (may exceed the ladder top). */
+function nextRungAbove(x, rf) {
+	const incHere = incrementAt(x, rf);
+	const incs = [incHere, incrementAt(add(x, incHere), rf)];
+	let best = null;
+	for (const inc of incs) {
+		const c = fixUp(ceilMultipleStrict(x, inc), rf);
+		if (cmp(c, x) > 0 && (best === null || cmp(c, best) < 0)) best = c;
+	}
+	if (best === null) throw new PanopticValidationError("No ladder rung above price");
+	return best;
+}
+/** Largest rung strictly below `x` (may fall below the ladder floor). */
+function prevRungBelow(x, rf) {
+	const incHere = incrementAt(x, rf);
+	const finer = incrementAt(sub(x, incHere), rf);
+	let best = null;
+	for (const inc of [incHere, finer]) {
+		const c = fixDown(floorMultipleStrict(x, inc), rf);
+		if (c.numerator > 0n && cmp(c, x) < 0 && (best === null || cmp(c, best) > 0)) best = c;
+	}
+	return best ?? fromBigint(0n);
+}
+/** Nearest rung price to a normalised price, or null when above the ladder. */
+function nearestRungPrice(normalised, rf) {
+	let rung;
+	if (isRung(normalised, rf)) rung = normalised;
+	else {
+		const up = nextRungAbove(normalised, rf);
+		const down = prevRungBelow(normalised, rf);
+		if (down.numerator <= 0n) rung = up;
+		else rung = cmp(sub(normalised, down), sub(up, normalised)) <= 0 ? down : up;
+	}
+	if (cmp(rung, LADDER_MIN) < 0) rung = LADDER_MIN;
+	if (cmp(rung, LADDER_MAX) > 0) return null;
+	return rung;
+}
+/** Step one rung up (+1) or down (-1) on the normalised ladder. Null when leaving it. */
+function stepRungPrice(rung, direction, rf) {
+	const next = direction > 0n ? nextRungAbove(rung, rf) : prevRungBelow(rung, rf);
+	if (cmp(next, LADDER_MIN) < 0 || cmp(next, LADDER_MAX) > 0) return null;
+	return next;
+}
+/** Nominal caller-oriented price of a rung as an exact fraction. */
+function rungToPrice(rung) {
+	return rung.reciprocal ? {
+		numerator: rung.price.denominator,
+		denominator: rung.price.numerator
+	} : rung.price;
+}
+function rungToPriceString(rung) {
+	return fractionToDecimal(rungToPrice(rung), PRICE_PRECISION);
+}
+function nearestRung(price, rf) {
+	const { value, reciprocal } = normalise(price);
+	const p = nearestRungPrice(value, rf);
+	return p === null ? null : {
+		price: p,
+		reciprocal
+	};
+}
+/**
+* Step a rung in the caller's price direction. For reciprocal quotes a higher
+* caller price is a lower normalised price, so the direction flips.
+*/
+function stepRung(rung, direction, rf) {
+	const normalisedDir = rung.reciprocal ? direction > 0n ? -1n : 1n : direction;
+	const p = stepRungPrice(rung.price, normalisedDir, rf);
+	return p === null ? null : {
+		price: p,
+		reciprocal: rung.reciprocal
+	};
+}
+/** Reject geometry the ladder cannot place: non-positive inputs or a span wider than the tick domain. */
+function validateGeometry(width, tickSpacing) {
+	if (width <= 0n) throw new PanopticValidationError("width must be positive");
+	if (tickSpacing <= 0n) throw new PanopticValidationError("tickSpacing must be positive");
+	if (width * tickSpacing > MAX_TICK - MIN_TICK) throw new PanopticValidationError("width * tickSpacing exceeds the tick domain");
+}
+/** `rangeDown`/`rangeUp` exactly as `PanopticMath.getRangesFromStrike`. */
+function rangesFromStrike(width, tickSpacing) {
+	const span = width * tickSpacing;
+	return {
+		rangeDown: span / 2n,
+		rangeUp: ceilDiv(span, 2n)
+	};
+}
+/**
+* Nearest valid strike tick to `exactTick` for `width`/`tickSpacing`.
+* Valid strikes satisfy `strike ≡ rangeDown (mod tickSpacing)`; the result is
+* shifted in whole tick spacings so the leg's ticks stay within `[MIN_TICK, MAX_TICK]`.
+*/
+function canonicalStrikeForWidth(exactTick, width, tickSpacing) {
+	validateGeometry(width, tickSpacing);
+	const { rangeDown, rangeUp } = rangesFromStrike(width, tickSpacing);
+	const offset = floorMod(rangeDown, tickSpacing);
+	let strike = roundDiv(exactTick - offset, tickSpacing) * tickSpacing + offset;
+	while (strike - rangeDown < MIN_TICK) strike += tickSpacing;
+	while (strike + rangeUp > MAX_TICK) strike -= tickSpacing;
+	return strike;
+}
+function rungToStrike(rung, geom) {
+	const nominalPrice = rungToPriceString(rung);
+	const exactTick = orientedPriceToTick(nominalPrice, geom.orient);
+	return {
+		tick: canonicalStrikeForWidth(exactTick, geom.width, geom.tickSpacing),
+		nominalPrice
+	};
+}
+function classifyTick(tick, geom, rf) {
+	const rung = nearestRung(tickToOrientedPrice(tick, geom.orient), rf);
+	if (rung === null) return { kind: "outside-ladder" };
+	const canonical = rungToStrike(rung, geom);
+	return canonical.tick === tick ? {
+		kind: "ladder",
+		nominalPrice: canonical.nominalPrice
+	} : { kind: "off-ladder" };
+}
+/**
+* A rung's canonical tick is only usable when that tick classifies back to the
+* same rung (`classifyStrike` → 'ladder'). When rungs are finer than the tick
+* grid two rungs can share a tick and only one of them "owns" it; return the
+* owner's strike, or null when this rung does not own its tick.
+*/
+function ownedStrike(rung, geom, rf) {
+	const strike = rungToStrike(rung, geom);
+	const cls = classifyTick(strike.tick, geom, rf);
+	return cls.kind === "ladder" ? {
+		tick: strike.tick,
+		nominalPrice: cls.nominalPrice
+	} : null;
+}
+/**
+* Classify a strike tick against the ladder for its width.
+*
+* - `ladder`: the tick is the canonical tick of its nearest rung → show `nominalPrice`.
+* - `off-ladder`: an in-range tick that is not a rung's canonical tick (e.g. real AMM
+*   liquidity at an arbitrary strike) → show the exact price.
+* - `outside-ladder`: the normalised price exceeds 1,000,000 → legacy behaviour.
+*/
+function classifyStrike(params) {
+	return classifyTick(params.tick, params, relativeStep(params.width, params.tickSpacing));
+}
+/**
+* Resolve a tick to a ladder strike.
+*
+* - `step` 0 (default): the ladder tick nearest to `tick` (the tick's own rung when
+*   it owns one, otherwise the closest owned neighbour).
+* - `step` ±1: the nearest ladder tick strictly beyond `tick` in that price direction
+*   (rungs finer than the tick grid can collapse onto one tick, so a single rung hop
+*   may not move the strike).
+*
+* Returns null when the target lies outside the ladder (normalised price > 1e6).
+*/
+function resolveLadderStrike(params) {
+	const step = params.step ?? 0n;
+	const rf = relativeStep(params.width, params.tickSpacing);
+	const start = nearestRung(tickToOrientedPrice(params.tick, params.orient), rf);
+	if (start === null) return null;
+	const startOriented = orientTick(params.tick, params.orient);
+	if (step === 0n) {
+		const own = ownedStrike(start, params, rf);
+		if (own !== null) return own;
+		let lo = start;
+		let hi = start;
+		for (let i = 0; i < MAX_STEP_ITERATIONS; i++) {
+			lo = lo === null ? null : stepRung(lo, -1n, rf);
+			hi = hi === null ? null : stepRung(hi, 1n, rf);
+			const a = lo === null ? null : ownedStrike(lo, params, rf);
+			const b = hi === null ? null : ownedStrike(hi, params, rf);
+			if (a !== null && b !== null) {
+				const da = startOriented - orientTick(a.tick, params.orient);
+				const db = orientTick(b.tick, params.orient) - startOriented;
+				return da <= db ? a : b;
+			}
+			if (a !== null) return a;
+			if (b !== null) return b;
+			if (lo === null && hi === null) return null;
+		}
+		return null;
+	}
+	let rung = start;
+	for (let i = 0; i < MAX_STEP_ITERATIONS && rung !== null; i++) {
+		const own = ownedStrike(rung, params, rf);
+		if (own !== null) {
+			const oriented = orientTick(own.tick, params.orient);
+			if (step > 0n ? oriented > startOriented : oriented < startOriented) return own;
+		}
+		rung = stepRung(rung, step, rf);
+	}
+	return null;
+}
+/**
+* Generate up to `count` ladder strikes centred on `centerTick`, sorted by
+* ascending caller price and deduplicated by tick. Rungs beyond the ladder are
+* omitted (the result may be shorter than `count`). Returns null when the
+* centre itself lies outside the ladder and `[]` when `count` is 0.
+*/
+function ladderStrikeSequence(params) {
+	const rf = relativeStep(params.width, params.tickSpacing);
+	if (params.count <= 0) return [];
+	const center = nearestRung(tickToOrientedPrice(params.centerTick, params.orient), rf);
+	if (center === null) return null;
+	const half = Math.floor(params.count / 2);
+	const below = [];
+	const above = [];
+	let r = center;
+	for (let i = 0; i < half && r !== null; i++) {
+		r = stepRung(r, -1n, rf);
+		if (r !== null) below.push(r);
+	}
+	r = center;
+	for (let i = 0; i < params.count - half - 1 && r !== null; i++) {
+		r = stepRung(r, 1n, rf);
+		if (r !== null) above.push(r);
+	}
+	const seen = new Set();
+	const out = [];
+	for (const rung of [
+		...below.reverse(),
+		center,
+		...above
+	]) {
+		const strike = ownedStrike(rung, params, rf);
+		if (strike === null || seen.has(strike.tick)) continue;
+		seen.add(strike.tick);
+		out.push(strike);
+	}
+	return out;
+}
+
 //#endregion
 //#region src/panoptic/v2/bot/index.ts
 /**
@@ -29186,5 +29818,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, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, 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, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, 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, orderListForSettle, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+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, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, 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, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, 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, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, 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, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=index.js.map