@panoptic-eng/sdk 1.0.47 → 1.0.48

package/dist/{writes-BZW7UA4N.js → writes-DBHwfbDD.js}

@@ -1,5 +1,5 @@
-import { BatchValidationError, DEFAULT_VEGOID, InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LoanSlotExhaustedError, MaxRetriesExceededError, MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError, PanopticError, PositionSnapshotNotFoundError, ProviderLagError, STRIKE_CONVERSION_FACTOR, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned, decodeOracleTiming, getBlockMeta, getOpenPositionIds, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositions, getPositionsKey, getSyncCheckpointKey, getTrackedPositionIds, jsonSerializer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError, submitWrite } from "./getTrackedPositionIds-CwBHzOO2.js";
-import { REORG_DEPTH, calculatePositionGreeks, tickLimits } from "./greeks-9aTE-DwO.js";
+import { BatchValidationError, DEFAULT_VEGOID, InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LoanSlotExhaustedError, MaxRetriesExceededError, MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError, PanopticError, PanopticValidationError, PositionSnapshotNotFoundError, ProviderLagError, STANDARD_TICK_WIDTHS, STRIKE_CONVERSION_FACTOR, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, UnsafePremiumSettlementError, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned, decodeOracleTiming, decodePosition, decodeTickSpacing, formatTokenAmount, getBlockMeta, getOpenPositionIds, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositions, getPositionsKey, getSyncCheckpointKey, getTrackedPositionIds, jsonSerializer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError, parseTokenAmount, submitWrite } from "./rates-5oQD-SuM.js";
+import { MAX_TICK, MIN_TICK, REORG_DEPTH, calculatePositionGreeks, priceToTick, roundToTickSpacing, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96 } from "./greeks-9aTE-DwO.js";
 import { decodeFunctionResult, encodeFunctionData, erc20Abi, getAbiItem } from "viem";
 
 //#region src/panoptic/v2/writes/broadcaster.ts
@@ -1572,350 +1572,525 @@ async function executeSettleSequenceAndWait(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/positionSizes.ts
-const BIT_MASK_128 = (1n << 128n) - 1n;
+//#region src/panoptic/v2/formatters/percentage.ts
 /**
-* Returns the current stored positionSize for each tokenId, in the same order
-* as the input `positionIdList`. Reverts (via the contract) if any tokenId is
-* not held by `account`.
+* Percentage and ratio formatters.
+*
+* All formatters require explicit precision - no hidden defaults.
+*
+* @module v2/formatters/percentage
 */
-async function getCurrentPositionSizes(params) {
-	const { client, poolAddress, account, positionIdList, blockNumber } = params;
-	if (positionIdList.length === 0) return [];
-	const [, , positionBalances] = await client.readContract({
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			false,
-			positionIdList
-		],
-		blockNumber
-	});
-	return positionBalances.map((packed) => packed & BIT_MASK_128);
+const TEN$2 = 10n;
+function formatRatio$2(numerator, denominator, precision) {
+	if (precision < 0n) throw new RangeError("Precision must be non-negative");
+	if (denominator === 0n) return "0";
+	const isNegative = numerator < 0n !== denominator < 0n;
+	const absNumerator = numerator < 0n ? -numerator : numerator;
+	const absDenominator = denominator < 0n ? -denominator : denominator;
+	const scale = TEN$2 ** precision;
+	const scaled = (absNumerator * scale + absDenominator / 2n) / absDenominator;
+	const integerPart = scaled / scale;
+	const fractionalPart = scaled % scale;
+	const sign = isNegative ? "-" : "";
+	if (precision === 0n) return `${sign}${integerPart}`;
+	return `${sign}${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
 }
-
-//#endregion
-//#region src/panoptic/v2/writes/settle.ts
 /**
-* Settle accumulated premia on existing positions.
+* Format basis points as a percentage string.
+* 100 bps = 1%
 *
-* This function triggers premium collection without changing position size.
-* It calls dispatch with unchanged position lists.
+* @param bps - Basis points value
+* @param precision - Number of decimal places to display
+* @returns Formatted percentage string
 *
-* @param params - Settlement parameters
-* @returns TxResult
+* @example
+* ```typescript
+* formatBps(50n, 2n)   // "0.50%"
+* formatBps(50n, 1n)   // "0.5%"
+* formatBps(100n, 2n)  // "1.00%"
+* formatBps(1500n, 2n) // "15.00%"
+* formatBps(-50n, 2n)  // "-0.50%"
+* ```
+*/
+function formatBps(bps, precision) {
+	const isNegative = bps < 0n;
+	const absBps = isNegative ? -bps : bps;
+	const scaleFactor = 10n ** precision;
+	const scaled = absBps * scaleFactor / 100n;
+	const integerPart = scaled / scaleFactor;
+	const fractionalPart = scaled % scaleFactor;
+	const fractionalStr = fractionalPart.toString().padStart(Number(precision), "0");
+	const sign = isNegative ? "-" : "";
+	return precision > 0n ? `${sign}${integerPart}.${fractionalStr}%` : `${sign}${integerPart}%`;
+}
+/**
+* Format utilization as a percentage string.
+* Utilization is stored as 0n-10000n, where 10000n = 100%.
+*
+* @param util - Utilization value (0-10000)
+* @param precision - Number of decimal places to display
+* @returns Formatted percentage string
 *
 * @example
 * ```typescript
-* const result = await settleAccumulatedPremia({
-*   client,
-*   walletClient,
-*   account,
-*   poolAddress,
-*   positionIdList: existingPositions,
-* })
-* const receipt = await result.wait()
+* formatUtilization(7500n, 2n)  // "75.00%"
+* formatUtilization(7500n, 0n)  // "75%"
+* formatUtilization(10000n, 2n) // "100.00%"
+* formatUtilization(123n, 2n)   // "1.23%"
 * ```
 */
-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
-	});
-	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
-	});
+function formatUtilization(util, precision) {
+	return formatBps(util, precision);
 }
 /**
-* Settle premia and wait for confirmation.
+* Parse a percentage string to basis points.
+*
+* @param percent - Percentage string (e.g., "1.5%" or "1.5")
+* @returns Basis points value
+*
+* @example
+* ```typescript
+* parseBps("1.5%")  // 150n
+* parseBps("1.5")   // 150n
+* parseBps("100%")  // 10000n
+* parseBps("0.5%")  // 50n
+* ```
 */
-async function settleAccumulatedPremiaAndWait(params) {
-	const result = await settleAccumulatedPremia(params);
-	return result.wait();
+function parseBps(percent) {
+	const cleaned = percent.trim().replace(/%$/, "");
+	const isNegative = cleaned.startsWith("-");
+	const absValue = isNegative ? cleaned.slice(1) : cleaned;
+	const [integerStr, fractionalStr = ""] = absValue.split(".");
+	const paddedFractional = fractionalStr.padEnd(2, "0").slice(0, 2);
+	const integerPart = BigInt(integerStr || "0") * 100n;
+	const fractionalPart = BigInt(paddedFractional || "0");
+	const result = integerPart + fractionalPart;
+	return isNegative ? -result : result;
+}
+/**
+* Format a ratio as a percentage string.
+*
+* @param numerator - Numerator of the ratio
+* @param denominator - Denominator of the ratio
+* @param precision - Number of decimal places to display
+* @returns Formatted percentage string
+*
+* @example
+* ```typescript
+* formatRatioPercent(1n, 4n, 1n)  // "25.0%"
+* formatRatioPercent(3n, 4n, 2n)  // "75.00%"
+* ```
+*/
+function formatRatioPercent(numerator, denominator, precision) {
+	const scaledNumerator = numerator * 100n;
+	return `${formatRatio$2(scaledNumerator, denominator, precision)}%`;
 }
 
 //#endregion
-//#region src/panoptic/v2/writes/pokeOracle.ts
+//#region src/panoptic/v2/formatters/poolFormatters.ts
 /**
-* Poke the oracle to update its state.
+* Create pool-bound formatters that capture token decimals.
 *
-* This function can be called to advance the oracle epoch.
-* Note: The oracle can only be poked once per epoch (64 seconds).
+* Use this factory when working with a single pool to avoid passing
+* decimals at every call site.
 *
-* @param params - Poke oracle parameters
-* @returns TxResult
-* @throws OracleRateLimitedError if checkRateLimit is true and oracle was recently poked
+* @param config - Pool configuration with token decimals
+* @returns Pool-bound formatter functions
 *
 * @example
 * ```typescript
-* const result = await pokeOracle({
-*   client,
-*   walletClient,
-*   account,
-*   poolAddress,
+* // Get pool data
+* const pool = await getPool({ client, poolAddress })
+*
+* // Create formatters bound to this pool
+* const fmt = createPoolFormatters({
+*   decimals0: pool.token0Decimals,
+*   decimals1: pool.token1Decimals,
 * })
-* const receipt = await result.wait()
+*
+* // Now use without passing decimals each time
+* const priceStr = fmt.tickToPriceScaled(position.currentTick, 4n)
+* const amount0Str = fmt.formatAmount0(collateral.assets, 4n)
+* const amount1Str = fmt.formatAmount1(premia.token1, 2n)
+*
+* // Parse user input
+* const rawAmount0 = fmt.parseAmount0("1.5")
+* const rawAmount1 = fmt.parseAmount1("3000")
 * ```
 */
-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);
+function createPoolFormatters(config) {
+	const { decimals0, decimals1 } = config;
+	return {
+		decimals0,
+		decimals1,
+		tickToPrice(tick) {
+			return tickToPrice(tick);
+		},
+		tickToPriceScaled(tick, precision) {
+			return tickToPriceDecimalScaled(tick, decimals0, decimals1, precision);
+		},
+		tickToInversePriceScaled(tick, precision) {
+			return tickToPriceDecimalScaled(tick, decimals1, decimals0, precision);
+		},
+		priceToTick(price) {
+			return priceToTick(price, decimals0, decimals1);
+		},
+		formatAmount0(amount, precision) {
+			return formatTokenAmount(amount, decimals0, precision);
+		},
+		formatAmount1(amount, precision) {
+			return formatTokenAmount(amount, decimals1, precision);
+		},
+		parseAmount0(amount) {
+			return parseTokenAmount(amount, decimals0);
+		},
+		parseAmount1(amount) {
+			return parseTokenAmount(amount, decimals1);
 		}
-	}
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "pokeOracle",
-		args: [],
-		txOverrides
-	});
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/formatters/tokenList.ts
+const TEN$1 = 10n;
+function formatRatio$1(numerator, denominator, precision) {
+	if (precision < 0n) throw new RangeError("Precision must be non-negative");
+	const scale = TEN$1 ** precision;
+	const scaled = (numerator * scale + denominator / 2n) / denominator;
+	const integerPart = scaled / scale;
+	const fractionalPart = scaled % scale;
+	if (precision === 0n) return integerPart.toString();
+	return `${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
 }
 /**
-* Poke oracle and wait for confirmation.
+* Generate a token list ID for external token list integration.
+*
+* Token lists use a standardized format: `chainId:address`
+* This is compatible with most token list standards.
+*
+* @param chainId - The chain ID
+* @param address - The token address
+* @returns Token list ID string
+*
+* @example
+* ```typescript
+* getTokenListId(1n, '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2')
+* // "1:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+*
+* getTokenListId(11155111n, '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14')
+* // "11155111:0xfff9976782d46cc05630d1f6ebab18b2324d6b14"
+* ```
 */
-async function pokeOracleAndWait(params) {
-	const result = await pokeOracle(params);
-	return result.wait();
+function getTokenListId(chainId, address) {
+	return `${chainId}:${address.toLowerCase()}`;
 }
-
-//#endregion
-//#region src/panoptic/v2/writes/factory.ts
 /**
-* Deploy a new Panoptic pool via the factory.
+* Parse a token list ID back to chain ID and address.
 *
-* @param params - Deployment parameters (versioned: 'v3' or 'v4')
-* @returns Transaction result with hash and wait function
+* @param tokenListId - The token list ID string
+* @returns Object with chainId and address
+*
+* @example
+* ```typescript
+* parseTokenListId("1:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")
+* // { chainId: 1n, address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" }
+* ```
 */
-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
-	});
+function parseTokenListId(tokenListId) {
+	const [chainIdStr, address] = tokenListId.split(":");
+	if (!chainIdStr || !address) throw new Error(`Invalid token list ID: ${tokenListId}`);
+	return {
+		chainId: BigInt(chainIdStr),
+		address
+	};
 }
 /**
-* Deploy a new Panoptic pool and wait for confirmation.
+* Generate a pool ID string for display purposes.
+*
+* @param token0Symbol - Symbol of token0
+* @param token1Symbol - Symbol of token1
+* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
+* @returns Pool ID string
+*
+* @example
+* ```typescript
+* getPoolDisplayId('WETH', 'USDC', 500n)
+* // "WETH/USDC 0.05%"
+*
+* getPoolDisplayId('WBTC', 'ETH', 3000n)
+* // "WBTC/ETH 0.30%"
+* ```
 */
-async function deployNewPoolAndWait(params) {
-	const result = await deployNewPool(params);
-	return result.wait();
+function getPoolDisplayId(token0Symbol, token1Symbol, feeBps) {
+	return `${token0Symbol}/${token1Symbol} ${formatFeeTier(feeBps)}`;
+}
+/**
+* Format a fee tier for display.
+*
+* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
+* @returns Fee tier string
+*
+* @example
+* ```typescript
+* formatFeeTier(500n)   // "0.05%"
+* formatFeeTier(3000n)  // "0.30%"
+* formatFeeTier(10000n) // "1.0%"
+* ```
+*/
+function formatFeeTier(feeBps) {
+	const precision = feeBps < 10000n ? 2n : 1n;
+	const feeStr = formatRatio$1(feeBps, 10000n, precision);
+	return `${feeStr}%`;
 }
 
 //#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;
+//#region src/panoptic/v2/formatters/display.ts
+const TEN = 10n;
+function formatRatio(numerator, denominator, precision) {
+	if (precision < 0n) throw new RangeError("Precision must be non-negative");
+	const scale = TEN ** precision;
+	const scaled = (numerator * scale + denominator / 2n) / denominator;
+	const integerPart = scaled / scale;
+	const fractionalPart = scaled % scale;
+	if (precision === 0n) return integerPart.toString();
+	return `${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
+}
 /**
-* Apply a multiplier to a bigint gas value.
-* Uses integer arithmetic to avoid floating point issues.
+* Truncate an address for display.
+*
+* @param address - Full address
+* @param chars - Characters to show on each side (default: 4)
+* @returns Truncated address like "0x1234...5678"
+*
+* @example
+* ```typescript
+* truncateAddress('0x1234567890abcdef1234567890abcdef12345678')
+* // "0x1234...5678"
+*
+* truncateAddress('0x1234567890abcdef1234567890abcdef12345678', 6)
+* // "0x123456...345678"
+* ```
 */
-function applyMultiplier(value, multiplier) {
-	const bps = BigInt(Math.ceil(multiplier * 1e4));
-	return value * bps / 10000n;
+function truncateAddress(address, chars = 4) {
+	const charsBig = BigInt(chars);
+	const minLength = charsBig * 2n + 4n;
+	if (BigInt(address.length) <= minLength) return address;
+	return `${address.slice(0, Number(charsBig + 2n))}...${address.slice(-Number(charsBig))}`;
 }
 /**
-* Compute bumped gas parameters from the original transaction.
+* Format a Unix timestamp as an ISO date string (YYYY-MM-DD).
+*
+* @param timestamp - Unix timestamp in seconds
+* @returns ISO date string
+*
+* @example
+* ```typescript
+* formatTimestamp(1700000000n)  // "2023-11-14"
+* ```
 */
-function computeBumpedGas(originalMaxFeePerGas, originalMaxPriorityFeePerGas, explicitMaxFeePerGas, explicitMaxPriorityFeePerGas, multiplier) {
-	const maxFeePerGas = explicitMaxFeePerGas ?? applyMultiplier(originalMaxFeePerGas ?? 0n, multiplier);
-	const maxPriorityFeePerGas = explicitMaxPriorityFeePerGas ?? applyMultiplier(originalMaxPriorityFeePerGas ?? 0n, multiplier);
-	return {
-		maxFeePerGas,
-		maxPriorityFeePerGas
-	};
+function formatTimestamp(timestamp) {
+	const ms = timestamp * 1000n;
+	return new Date(Number(ms)).toISOString().split("T")[0];
 }
 /**
-* 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.
+* Format a Unix timestamp as an ISO datetime string.
 *
-* @param params - Speed up parameters
-* @returns TxResult for the replacement transaction
-* @throws Error if the original transaction is not found
+* @param timestamp - Unix timestamp in seconds
+* @returns ISO datetime string
 *
 * @example
 * ```typescript
-* // Speed up with default 12.5% bump
-* const result = await speedUpTransaction({
-*   client,
-*   walletClient,
-*   hash: pendingTxHash,
-* })
+* formatDatetime(1700000000n)  // "2023-11-14T22:13:20.000Z"
+* ```
+*/
+function formatDatetime(timestamp) {
+	const ms = timestamp * 1000n;
+	return new Date(Number(ms)).toISOString();
+}
+/**
+* Format a Unix timestamp as a locale-aware date string.
 *
-* // Speed up with explicit gas prices
-* const result = await speedUpTransaction({
-*   client,
-*   walletClient,
-*   hash: pendingTxHash,
-*   maxFeePerGas: 50_000_000_000n, // 50 gwei
-*   maxPriorityFeePerGas: 3_000_000_000n, // 3 gwei
-* })
+* @param timestamp - Unix timestamp in seconds
+* @param locale - Locale string (default: system locale)
+* @param options - Intl.DateTimeFormat options
+* @returns Formatted date string
+*
+* @example
+* ```typescript
+* formatTimestampLocale(1700000000n)
+* // "11/14/2023" (US locale)
+*
+* formatTimestampLocale(1700000000n, 'de-DE')
+* // "14.11.2023" (German locale)
 * ```
 */
-async function speedUpTransaction(params) {
-	const { client, walletClient, hash, maxFeePerGas: explicitMaxFee, maxPriorityFeePerGas: explicitMaxPriority, gasPriceMultiplier = DEFAULT_GAS_PRICE_MULTIPLIER, broadcaster } = params;
-	const tx = await client.getTransaction({ hash });
-	const { maxFeePerGas, maxPriorityFeePerGas } = computeBumpedGas(tx.maxFeePerGas ?? void 0, tx.maxPriorityFeePerGas ?? void 0, explicitMaxFee, explicitMaxPriority, gasPriceMultiplier);
-	if (broadcaster) {
-		const request = await walletClient.prepareTransactionRequest({
-			account: tx.from,
-			to: tx.to ?? void 0,
-			data: tx.input,
-			value: tx.value,
-			nonce: tx.nonce,
-			gas: tx.gas,
-			maxFeePerGas,
-			maxPriorityFeePerGas,
-			chain: walletClient.chain
-		});
-		const signedTx = await walletClient.signTransaction({
-			...request,
-			account: tx.from
-		});
-		const replacementHash$1 = await broadcaster.broadcast(signedTx);
-		return createTxResult(client, replacementHash$1);
-	}
-	const replacementHash = await walletClient.sendTransaction({
-		account: tx.from,
-		to: tx.to ?? void 0,
-		data: tx.input,
-		value: tx.value,
-		nonce: tx.nonce,
-		gas: tx.gas,
-		maxFeePerGas,
-		maxPriorityFeePerGas,
-		chain: walletClient.chain
-	});
-	return createTxResult(client, replacementHash);
+function formatTimestampLocale(timestamp, locale, options) {
+	const ms = timestamp * 1000n;
+	return new Date(Number(ms)).toLocaleDateString(locale, options);
 }
 /**
-* Cancel a pending transaction by sending a 0-value self-transfer
-* with the same nonce and higher gas price.
+* Format a duration in milliseconds as a human-readable string.
 *
-* @param params - Cancel parameters
-* @returns TxResult for the cancellation transaction
-* @throws Error if the original transaction is not found
+* @param ms - Duration in milliseconds
+* @returns Formatted duration string
 *
 * @example
 * ```typescript
-* const result = await cancelTransaction({
-*   client,
-*   walletClient,
-*   account,
-*   hash: pendingTxHash,
-* })
-* await result.wait()
+* formatDuration(1500n)   // "1.5s"
+* formatDuration(150n)    // "150ms"
+* formatDuration(90000n)  // "1m 30s"
+* formatDuration(3661000n) // "1h 1m"
 * ```
 */
-async function cancelTransaction(params) {
-	const { client, walletClient, account, hash, maxFeePerGas: explicitMaxFee, maxPriorityFeePerGas: explicitMaxPriority, gasPriceMultiplier = DEFAULT_GAS_PRICE_MULTIPLIER, broadcaster } = params;
-	const tx = await client.getTransaction({ hash });
-	const { maxFeePerGas, maxPriorityFeePerGas } = computeBumpedGas(tx.maxFeePerGas ?? void 0, tx.maxPriorityFeePerGas ?? void 0, explicitMaxFee, explicitMaxPriority, gasPriceMultiplier);
-	if (broadcaster) {
-		const request = await walletClient.prepareTransactionRequest({
-			account,
-			to: account,
-			value: 0n,
-			nonce: tx.nonce,
-			gas: 21000n,
-			maxFeePerGas,
-			maxPriorityFeePerGas,
-			chain: walletClient.chain
-		});
-		const signedTx = await walletClient.signTransaction({
-			...request,
-			account
-		});
-		const cancelHash$1 = await broadcaster.broadcast(signedTx);
-		return createTxResult(client, cancelHash$1);
+function formatDuration(ms) {
+	const isNegative = ms < 0n;
+	const absMs = isNegative ? -ms : ms;
+	const sign = isNegative ? "-" : "";
+	if (absMs < 1000n) return `${sign}${absMs}ms`;
+	if (absMs < 60000n) {
+		const tenthsTotal = (absMs + 50n) / 100n;
+		const seconds = tenthsTotal / 10n;
+		const tenths = tenthsTotal % 10n;
+		return `${sign}${seconds}.${tenths}s`;
 	}
-	const cancelHash = await walletClient.sendTransaction({
-		account,
-		to: account,
-		value: 0n,
-		nonce: tx.nonce,
-		gas: 21000n,
-		maxFeePerGas,
-		maxPriorityFeePerGas,
-		chain: walletClient.chain
-	});
-	return createTxResult(client, cancelHash);
+	if (absMs < 3600000n) {
+		const minutes$1 = absMs / 60000n;
+		const seconds = (absMs % 60000n + 500n) / 1000n;
+		return seconds > 0n ? `${sign}${minutes$1}m ${seconds}s` : `${sign}${minutes$1}m`;
+	}
+	const hours = absMs / 3600000n;
+	const minutes = (absMs % 3600000n + 30000n) / 60000n;
+	return minutes > 0n ? `${sign}${hours}h ${minutes}m` : `${sign}${hours}h`;
+}
+/**
+* Format a duration in seconds as a human-readable string.
+*
+* @param seconds - Duration in seconds
+* @returns Formatted duration string
+*/
+function formatDurationSeconds(seconds) {
+	return formatDuration(seconds * 1000n);
+}
+/**
+* Format a block number for display.
+*
+* @param blockNumber - The block number
+* @returns Formatted block number with commas
+*
+* @example
+* ```typescript
+* formatBlockNumber(18000000n)  // "18,000,000"
+* ```
+*/
+function formatBlockNumber(blockNumber) {
+	return blockNumber.toLocaleString();
+}
+/**
+* Format a gas amount for display.
+*
+* @param gas - Gas units
+* @returns Formatted gas string
+*/
+function formatGas(gas) {
+	return gas.toLocaleString();
+}
+/**
+* Format a transaction hash for display (truncated).
+*
+* @param hash - Full transaction hash
+* @param chars - Characters to show on each side (default: 6)
+* @returns Truncated hash like "0x123456...abcdef"
+*
+* @example
+* ```typescript
+* formatTxHash('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef')
+* // "0x123456...abcdef"
+* ```
+*/
+function formatTxHash(hash, chars = 6) {
+	const charsBig = BigInt(chars);
+	const minLength = charsBig * 2n + 4n;
+	if (BigInt(hash.length) <= minLength) return hash;
+	return `${hash.slice(0, Number(charsBig + 2n))}...${hash.slice(-Number(charsBig))}`;
+}
+function formatHex(value) {
+	return `0x${value.toString(16)}`;
+}
+/**
+* Format a TokenId as a hex string.
+*
+* @param tokenId - TokenId value
+* @returns Hex string representation
+*/
+function formatTokenIdHex(tokenId) {
+	return formatHex(tokenId);
+}
+/**
+* Format a PoolId as a hex string.
+*
+* @param poolId - PoolId value
+* @returns Hex string representation
+*/
+function formatPoolIdHex(poolId) {
+	return formatHex(poolId);
+}
+/**
+* Format a TokenId as a shortened hex string.
+*
+* @param tokenId - TokenId value
+* @param chars - Characters to show on each side (default: 4)
+* @returns Truncated hex string like "0x1234...abcd"
+*/
+function formatTokenIdShort(tokenId, chars = 4) {
+	const hex = formatHex(tokenId);
+	const charsBig = BigInt(chars);
+	const minLength = charsBig * 2n + 4n;
+	if (BigInt(hex.length) <= minLength) return hex;
+	return `${hex.slice(0, Number(charsBig + 2n))}...${hex.slice(-Number(charsBig))}`;
+}
+/**
+* Format a large number with K/M/B suffixes.
+*
+* @param value - The numeric value
+* @param precision - Number of decimal places (default: 1n)
+* @returns Formatted string with suffix
+*
+* @example
+* ```typescript
+* formatCompact(1234n)        // "1.2K"
+* formatCompact(1234567n)     // "1.2M"
+* formatCompact(1234567890n)  // "1.2B"
+* formatCompact(999n)         // "999"
+* ```
+*/
+function formatCompact(value, precision = 1n) {
+	const isNegative = value < 0n;
+	const absValue = isNegative ? -value : value;
+	let formatted;
+	if (absValue < 1000n) formatted = absValue.toString();
+	else if (absValue < 1000000n) formatted = `${formatRatio(absValue, 1000n, precision)}K`;
+	else if (absValue < 1000000000n) formatted = `${formatRatio(absValue, 1000000n, precision)}M`;
+	else formatted = `${formatRatio(absValue, 1000000000n, precision)}B`;
+	return isNegative ? `-${formatted}` : formatted;
+}
+/**
+* Format a wei amount as a display string.
+*
+* @param wei - Amount in wei
+* @returns Formatted string with unit
+*/
+function formatWei(wei) {
+	return `${wei} wei`;
+}
+/**
+* Format a wei amount as gwei.
+*
+* @param wei - Amount in wei
+* @param precision - Number of decimal places to display
+* @returns Formatted string with unit
+*/
+function formatGwei(wei, precision) {
+	return `${formatTokenAmount(wei, 9n, precision)} gwei`;
 }
 
 //#endregion
@@ -2006,7 +2181,7 @@ function decodeVegoid(tokenId) {
 * @param tokenId - The TokenId to decode
 * @returns The tick spacing
 */
-function decodeTickSpacing(tokenId) {
+function decodeTickSpacing$1(tokenId) {
 	const poolId = tokenId & (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
 	return poolId >> TOKEN_ID_BITS.TICK_SPACING_STARTING_BIT;
 }
@@ -2217,766 +2392,1149 @@ function createTokenIdBuilder(poolId) {
 }
 
 //#endregion
-//#region src/panoptic/v2/writes/loanUtils.ts
-/** Maximum retry attempts on InputListFail */
-const MAX_RETRIES = 3;
+//#region src/panoptic/v2/tokenId/decode.ts
 /**
-* Resolve token index (0 or 1) for the given token address against the pool.
-* Throws SwapTokenMismatchError if the token isn't in the pool.
+* Convert a DecodedLeg to TokenIdLeg format.
+*
+* @param leg - The decoded leg from encoding utils
+* @param tickSpacing - The tick spacing for calculating tick bounds
+* @returns The TokenIdLeg format
 */
-function resolveTokenIndex(tokenAddress, token0, token1) {
-	const lower = tokenAddress.toLowerCase();
-	if (lower === token0.toLowerCase()) return 0n;
-	if (lower === token1.toLowerCase()) return 1n;
-	throw new SwapTokenMismatchError(tokenAddress, token0, token1);
+function convertToTokenIdLeg(leg, tickSpacing) {
+	const halfWidth = leg.width * tickSpacing / 2n;
+	const tickLower = leg.strike - halfWidth;
+	const tickUpper = leg.strike + halfWidth;
+	return {
+		index: leg.index,
+		asset: leg.asset,
+		optionRatio: leg.optionRatio,
+		isLong: leg.isLong,
+		tokenType: leg.tokenType,
+		riskPartner: leg.riskPartner,
+		strike: leg.strike,
+		width: leg.width,
+		tickLower,
+		tickUpper
+	};
 }
 /**
-* Resolve existing position IDs from explicit param or storage.
+* Decode a TokenId into its component parts.
+*
+* @param tokenId - The TokenId to decode
+* @returns The decoded TokenId data
+*
+* @example
+* ```typescript
+* const decoded = decodeTokenId(tokenId)
+* console.log(decoded.legs) // Array of legs
+* console.log(decoded.tickSpacing) // Tick spacing
+* ```
 */
-async function resolvePositionIds(explicit, storage, chainId, poolAddress, account) {
-	if (explicit !== void 0) return explicit;
-	if (storage) return getTrackedPositionIds({
-		chainId,
-		poolAddress,
-		account,
-		storage
-	});
-	throw new MissingPositionIdsError();
+function decodeTokenId(tokenId) {
+	const poolId = decodePoolId(tokenId);
+	const vegoid = decodeVegoid(tokenId);
+	const tickSpacing = decodeTickSpacing$1(tokenId);
+	const rawLegs = decodeAllLegs(tokenId);
+	const numLegs = countLegs(tokenId);
+	const legs = rawLegs.map((leg) => convertToTokenIdLeg(leg, tickSpacing));
+	return {
+		tokenId,
+		poolId,
+		vegoid,
+		tickSpacing,
+		legs,
+		legCount: numLegs
+	};
 }
 /**
-* Check if a caught error is an InputListFail contract revert.
-* Works with both raw viem errors and parsed PanopticError instances.
+* Validate that a TokenId has the expected pool ID.
+*
+* @param tokenId - The TokenId to validate
+* @param expectedPoolId - The expected pool ID
+* @returns True if the pool IDs match
 */
-function isInputListFailError(error) {
-	if (error instanceof InputListFailError) return true;
-	const parsed = parsePanopticError(error);
-	return parsed?.errorName === "InputListFail";
+function validatePoolId(tokenId, expectedPoolId) {
+	const actualPoolId = tokenId & (1n << 64n) - 1n;
+	return actualPoolId === expectedPoolId;
 }
 /**
-* Build a unique width=0 tokenId that doesn't collide with existing positions.
-* Bumps optionRatio (1-127) and returns adjusted size to maintain equivalent exposure.
+* Check if a TokenId represents a long position (any leg is long).
 *
-* @param kind - Whether to build a loan (borrow) or a credit (pay-in) leg.
-* @param asset - Which token denominates the positionSize (0 or 1).
+* @param tokenId - The TokenId to check
+* @returns True if any leg is long
 */
-function buildUniqueWidthZeroLeg(kind, poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
-	const addLeg = (strike$1, optionRatio) => {
-		const builder = createTokenIdBuilder(poolId);
-		const config = {
-			asset,
-			tokenType,
-			strike: strike$1,
-			optionRatio
-		};
-		return (kind === "loan" ? builder.addLoan(config) : builder.addCredit(config)).build();
-	};
-	const mod = currentTick % tickSpacing;
-	let strike = currentTick - (mod + tickSpacing) % tickSpacing;
-	for (let ratio = 1n; ratio <= 127n; ratio++) {
-		const tokenId = addLeg(strike, ratio);
-		if (!existingPositionIds.includes(tokenId)) {
-			const adjustedSize = positionSize / ratio;
-			if (adjustedSize === 0n || positionSize % ratio !== 0n) continue;
-			return {
-				tokenId,
-				adjustedSize
-			};
-		}
-	}
-	const mod2 = currentTick % tickSpacing;
-	strike = currentTick - (mod2 + tickSpacing) % tickSpacing + tickSpacing;
-	for (let i = 0; i < 100; i++) {
-		const tokenId = addLeg(strike);
-		if (!existingPositionIds.includes(tokenId)) return {
-			tokenId,
-			adjustedSize: positionSize
-		};
-		strike += tickSpacing;
-	}
-	throw new LoanSlotExhaustedError();
+function hasLongLeg(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.isLong);
 }
 /**
-* Build a unique loan (borrow) tokenId that doesn't collide with existing positions.
+* Check if a TokenId represents a short-only position.
 *
-* @param asset - Which token denominates the positionSize (0 or 1).
+* @param tokenId - The TokenId to check
+* @returns True if all legs are short
 */
-function buildUniqueLoan(poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
-	return buildUniqueWidthZeroLeg("loan", poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize);
+function isShortOnly(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every((leg) => !leg.isLong);
 }
 /**
-* Build a unique credit (pay-in) tokenId that doesn't collide with existing positions.
-*
-* Unlike a loan, a credit never borrows from the pool: it requires **zero** buying
-* power, leaves `s_assetsInAMM` (and therefore utilization and the borrow rate)
-* untouched, and accrues no interest. This is what lets a credit-based swap run
-* against a fully-utilized collateral tracker.
+* Check if a TokenId represents a spread (legs with different risk partners).
 *
-* @param asset - Which token denominates the positionSize (0 or 1).
+* @param tokenId - The TokenId to check
+* @returns True if any leg has a different risk partner
 */
-function buildUniqueCredit(poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
-	return buildUniqueWidthZeroLeg("credit", poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize);
-}
-
-//#endregion
-//#region src/panoptic/v2/writes/swap.ts
-/** Build an atomic credit mint/burn swap without fetching or sending anything. */
-function buildCreditSwapCall(params) {
-	const amount = params.kind === "exactIn" ? params.amountIn : params.amountOut;
-	if (amount <= 0n) throw new Error("credit swap amount must be positive");
-	if (params.tokenIndex !== 0n && params.tokenIndex !== 1n) throw new Error("credit swap tokenIndex must be 0 or 1");
-	const { low, high } = tickLimits(params.currentTick, params.slippageBps);
-	const { tokenId: creditTokenId, adjustedSize } = buildUniqueCredit(params.poolId, params.tokenIndex, params.tokenIndex, params.currentTick, params.tickSpacing, params.existingPositionIds, amount);
-	const ascending = [
-		Number(low),
-		Number(high),
-		0
-	];
-	const descending = [
-		Number(high),
-		Number(low),
-		0
-	];
-	const limits = params.kind === "exactIn" ? [ascending, descending] : [descending, ascending];
-	const args = [
-		[creditTokenId, creditTokenId],
-		[...params.existingPositionIds],
-		[adjustedSize, 0n],
-		limits,
-		false,
-		params.builderCode ?? 0n
-	];
-	return {
-		to: params.poolAddress,
-		data: encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatch",
-			args
-		}),
-		creditTokenId,
-		adjustedSize,
-		args
-	};
+function isSpread(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.riskPartner !== leg.index);
 }
 /**
-* Swap tokens using Panoptic's exact-output mechanism.
-*
-* Opens a credit in `tokenOut` with `swapAtMint=true` (paying a swapped amount of
-* the other token), then burns it with `swapAtMint=false` to receive exactly
-* `amountOut` of `tokenOut`.
-*
-* @param params - Swap parameters
-* @returns TxResult
+* Get the asset index for a TokenId (from the first leg).
 *
-* @example
-* ```typescript
-* const result = await swapExactOut({
-*   client, walletClient, account, poolAddress,
-*   chainId: 11155111n,
-*   tokenOut: WETH_ADDRESS,
-*   amountOut: 5n * 10n**16n,  // 0.05 WETH
-*   slippageBps: 500n,         // 5% slippage
-* })
-* const receipt = await result.wait()
-* ```
+* @param tokenId - The TokenId
+* @returns The asset index (0 or 1), or undefined if no legs
 */
-async function swapExactOut(params) {
-	const { client, walletClient, account, poolAddress, chainId, tokenOut, amountOut, slippageBps, existingPositionIds: explicitIds, storage, builderCode = 0n, txOverrides } = params;
-	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-		const [pool, positionIds] = await Promise.all([getPool({
-			client,
-			poolAddress,
-			chainId
-		}), resolvePositionIds(explicitIds, storage, chainId, poolAddress, account)]);
-		const token0 = pool.collateralTracker0.token;
-		const token1 = pool.collateralTracker1.token;
-		const tokenOutIndex = resolveTokenIndex(tokenOut, token0, token1);
-		const call = buildCreditSwapCall({
-			kind: "exactOut",
-			poolAddress,
-			poolId: pool.poolId,
-			currentTick: pool.currentTick,
-			tickSpacing: pool.tickSpacing,
-			existingPositionIds: positionIds,
-			tokenIndex: tokenOutIndex,
-			amountOut,
-			slippageBps,
-			builderCode
-		});
-		try {
-			return await submitWrite({
-				client,
-				walletClient,
-				account,
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "dispatch",
-				args: call.args,
-				txOverrides
-			});
-		} catch (error) {
-			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
-			throw error;
-		}
-	}
-	throw new MaxRetriesExceededError("swapExactOut");
+function getAssetIndex(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	if (legs.length === 0) return void 0;
+	return legs[0].asset;
 }
 /**
-* Swap exact output and wait for confirmation.
+* Check if a leg is a loan (width=0 and isLong=false).
+*
+* Loans borrow liquidity from the pool at a specific strike price.
+*
+* @param leg - The decoded leg to check
+* @returns True if the leg is a loan
 */
-async function swapExactOutAndWait(params) {
-	const result = await swapExactOut(params);
-	return result.wait();
+function isLoanLeg(leg) {
+	return leg.width === 0n && !leg.isLong;
 }
 /**
-* Swap tokens using Panoptic's exact-input mechanism.
+* Check if a leg is a credit (width=0 and isLong=true).
 *
-* Opens a credit in `tokenIn` with `swapAtMint=false` (paying exactly `amountIn`),
-* then burns it with `swapAtMint=true` to receive the swapped amount of the other
-* token. The user spends exactly `amountIn` of `tokenIn`.
+* Credits lend liquidity to the pool at a specific strike price.
 *
-* @param params - Swap parameters
-* @returns TxResult
+* @param leg - The decoded leg to check
+* @returns True if the leg is a credit
+*/
+function isCreditLeg(leg) {
+	return leg.width === 0n && leg.isLong;
+}
+/**
+* Check if a TokenId is a pure loan (all legs are loans).
 *
-* @example
-* ```typescript
-* const result = await swapExactIn({
-*   client, walletClient, account, poolAddress,
-*   chainId: 11155111n,
-*   tokenIn: USDC_ADDRESS,
-*   amountIn: 1000n * 10n**6n,  // 1000 USDC
-*   slippageBps: 500n,
-* })
-* const receipt = await result.wait()
-* ```
+* @param tokenId - The TokenId to check
+* @returns True if all legs are loans
 */
-async function swapExactIn(params) {
-	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountIn, slippageBps, existingPositionIds: explicitIds, storage, builderCode = 0n, txOverrides } = params;
-	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-		const [pool, positionIds] = await Promise.all([getPool({
-			client,
-			poolAddress,
-			chainId
-		}), resolvePositionIds(explicitIds, storage, chainId, poolAddress, account)]);
-		const token0 = pool.collateralTracker0.token;
-		const token1 = pool.collateralTracker1.token;
-		const tokenInIndex = resolveTokenIndex(tokenIn, token0, token1);
-		const call = buildCreditSwapCall({
-			kind: "exactIn",
-			poolAddress,
-			poolId: pool.poolId,
-			currentTick: pool.currentTick,
-			tickSpacing: pool.tickSpacing,
-			existingPositionIds: positionIds,
-			tokenIndex: tokenInIndex,
-			amountIn,
-			slippageBps,
-			builderCode
-		});
-		try {
-			return await submitWrite({
-				client,
-				walletClient,
-				account,
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "dispatch",
-				args: call.args,
-				txOverrides
-			});
-		} catch (error) {
-			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
-			throw error;
-		}
-	}
-	throw new MaxRetriesExceededError("swapExactIn");
+function isLoan(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every(isLoanLeg);
 }
 /**
-* Swap exact input and wait for confirmation.
+* Check if a TokenId is a pure credit (all legs are credits).
+*
+* @param tokenId - The TokenId to check
+* @returns True if all legs are credits
 */
-async function swapExactInAndWait(params) {
-	const result = await swapExactIn(params);
-	return result.wait();
+function isCredit(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every(isCreditLeg);
 }
-
-//#endregion
-//#region src/panoptic/v2/writes/wrap.ts
-/** Minimal ERC4626 surface used by the xStock wrappers. */
-const xstockWrapperAbi = [
-	{
-		type: "function",
-		name: "deposit",
-		stateMutability: "nonpayable",
-		inputs: [{
-			name: "assets",
-			type: "uint256"
-		}, {
-			name: "receiver",
-			type: "address"
-		}],
-		outputs: [{
-			name: "shares",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "function",
-		name: "redeem",
-		stateMutability: "nonpayable",
-		inputs: [
-			{
-				name: "shares",
-				type: "uint256"
-			},
-			{
-				name: "receiver",
-				type: "address"
-			},
-			{
-				name: "owner",
-				type: "address"
-			}
-		],
-		outputs: [{
-			name: "assets",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "function",
-		name: "asset",
-		stateMutability: "view",
-		inputs: [],
-		outputs: [{ type: "address" }]
-	},
-	{
-		type: "function",
-		name: "previewDeposit",
-		stateMutability: "view",
-		inputs: [{
-			name: "assets",
-			type: "uint256"
-		}],
-		outputs: [{
-			name: "shares",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "function",
-		name: "previewRedeem",
-		stateMutability: "view",
-		inputs: [{
-			name: "shares",
-			type: "uint256"
-		}],
-		outputs: [{
-			name: "assets",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "function",
-		name: "maxRedeem",
-		stateMutability: "view",
-		inputs: [{
-			name: "owner",
-			type: "address"
-		}],
-		outputs: [{
-			name: "maxShares",
-			type: "uint256"
-		}]
-	}
-];
 /**
-* Wrap an underlying xStock into its ERC4626 wrapper (`deposit`). Requires a
-* prior ERC20 approval of the underlying to the wrapper address.
+* Check if a TokenId contains loan or credit legs (width=0).
 *
-* @returns TxResult with hash and wait function
+* @param tokenId - The TokenId to check
+* @returns True if any leg has width=0 (loan or credit)
 */
-async function wrapXstock(params) {
-	const { client, walletClient, account, wrapper, assets, receiver = account, txOverrides } = params;
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: wrapper,
-		abi: xstockWrapperAbi,
-		functionName: "deposit",
-		args: [assets, receiver],
-		txOverrides
-	});
-}
-/** Wrap and wait for confirmation. */
-async function wrapXstockAndWait(params) {
-	const result = await wrapXstock(params);
-	return result.wait();
+function hasLoanOrCredit(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.width === 0n);
 }
+
+//#endregion
+//#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
+const POOL_ID_MASK$2 = (1n << 64n) - 1n;
+const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
+const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
+const Q192$1 = 1n << 192n;
 /**
-* Unwrap wrapper shares back into the underlying xStock (`redeem`). When
-* `owner` defaults to (or equals) `account` the caller burns their own shares
-* and no approval is needed. Passing a different `owner` redeems on its behalf
-* and requires that owner to have granted the caller an ERC-4626 share
-* allowance (`approve`), or the `redeem` call reverts.
-*
-* @returns TxResult with hash and wait function
+* Floor integer square root for bigints (Newton's method). Mirrors the isqrt
+* used in reads/collateralEstimate.ts (buildNeutralLeg).
 */
-async function unwrapXstock(params) {
-	const { client, walletClient, account, wrapper, shares, receiver = account, owner = account, txOverrides } = params;
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: wrapper,
-		abi: xstockWrapperAbi,
-		functionName: "redeem",
-		args: [
-			shares,
-			receiver,
-			owner
-		],
-		txOverrides
-	});
-}
-/** Unwrap and wait for confirmation. */
-async function unwrapXstockAndWait(params) {
-	const result = await unwrapXstock(params);
-	return result.wait();
+function isqrt(value) {
+	if (value < 0n) throw new PanopticError("isqrt of negative number");
+	if (value < 2n) return value;
+	let x = value;
+	let y = x + 1n >> 1n;
+	while (y < x) {
+		x = y;
+		y = x + value / x >> 1n;
+	}
+	return x;
 }
+const DEFAULT_TICK_SPACING = 200n;
 /**
-* Preview the wrapper shares minted for a given amount of underlying xStock.
+* Target notional (in wei of the tokenType-side asset) for the appended
+* tiny credit leg. Chosen at 10 wei — small enough to be economically
+* meaningless against any real position size, large enough to safely
+* clear rounding on the SFPM's width-2 internal chunk math without any
+* risk of underflowing to zero (which would revert ChunkHasZeroLiquidity).
 */
-async function previewWrap(params) {
-	const { client, wrapper, amount } = params;
-	return client.readContract({
-		address: wrapper,
-		abi: xstockWrapperAbi,
-		functionName: "previewDeposit",
-		args: [amount]
-	});
-}
+const TINY_CREDIT_TARGET_NOTIONAL_WEI = 10n;
 /**
-* Preview the underlying xStock returned for a given amount of wrapper shares.
+* Pick a signedStrike for the appended width=0 credit leg such that:
+*   1. positionSize · 1.0001^signedStrike ≈ TINY_CREDIT_TARGET_NOTIONAL_WEI
+*      (~10 wei — economically meaningless but comfortably above any
+*      SFPM width-2 chunk rounding);
+*   2. the leg's tick range (SFPM internally treats width=0 as width=2, so
+*      the range is `strike ± tickSpacing`) stays strictly inside
+*      `[MIN_POOL_TICK, MAX_POOL_TICK]` — otherwise the getSqrtRatioAtTick
+*      call reverts with `InvalidTick`.
+*
+* Closed form: `1.0001^signedStrike = target/positionSize`, so
+* `sqrtKrawX96 = isqrt(target · 2^192 / positionSize)` and
+* `signedStrike = sqrtPriceX96ToTick(sqrtKrawX96)`. If the notional-optimal
+* strike falls outside the safe range, we clamp inward. Clamping raises the
+* notional but keeps it << position size for any reasonable strike.
 */
-async function previewUnwrap(params) {
-	const { client, wrapper, amount } = params;
-	return client.readContract({
-		address: wrapper,
-		abi: xstockWrapperAbi,
-		functionName: "previewRedeem",
-		args: [amount]
-	});
+function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
+	if (positionSize <= 0n) throw new PanopticError("computeTinyCreditSignedStrike: positionSize must be > 0");
+	const minSafe = MIN_TICK + tickSpacing + 1n;
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike;
+	try {
+		const sqrtKrawX96 = isqrt(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$1 / positionSize);
+		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
+	} catch {
+		signedStrike = minSafe;
+	}
+	if (signedStrike < minSafe) return minSafe;
+	if (signedStrike > maxSafe) return maxSafe;
+	return signedStrike;
 }
 /**
-* Minimal canonical WETH9 surface used for ETH<->WETH wrapping. Unlike the
-* ERC4626 xStock wrapper, WETH is a 1:1 wrapper: `deposit` is payable and wraps
-* `msg.value`, `withdraw` unwraps an exact amount back to native ETH.
-*/
-const wethWrapAbi = [{
-	type: "function",
-	name: "deposit",
-	stateMutability: "payable",
-	inputs: [],
-	outputs: []
-}, {
-	type: "function",
-	name: "withdraw",
-	stateMutability: "nonpayable",
-	inputs: [{
-		name: "wad",
-		type: "uint256"
-	}],
-	outputs: []
-}];
-/**
-* Wrap native ETH into WETH (`deposit` payable). No approval needed.
+* Assemble the tiny credit leg struct, picking a strike that avoids
+* colliding with any existing width=0 credit leg on the same (asset,
+* tokenType) pair.
 *
-* @returns TxResult with hash and wait function
+* The encoded strike stored in the tokenId is
+* `asset === 0 ? signedStrike : -signedStrike` (mirrors
+* {@link buildNeutralLeg} in reads/collateralEstimate.ts).
 */
-async function wrapEth(params) {
-	const { client, walletClient, account, weth, amount, txOverrides } = params;
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: weth,
-		abi: wethWrapAbi,
-		functionName: "deposit",
-		args: [],
-		value: amount,
-		txOverrides
-	});
+function pickUniqueTinyCreditLeg(baseTokenId, legIndex, positionSize, tickSpacing) {
+	const asset = 1n;
+	const tokenType = 0n;
+	const existingLegs = decodeAllLegs(baseTokenId);
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike = computeTinyCreditSignedStrike(positionSize, tickSpacing);
+	while (signedStrike <= maxSafe) {
+		const candidate = asset === 0n ? signedStrike : -signedStrike;
+		let collides = false;
+		for (const leg of existingLegs) if (leg.width === 0n && leg.isLong && leg.asset === asset && leg.tokenType === tokenType && leg.strike === candidate) {
+			collides = true;
+			break;
+		}
+		if (!collides) break;
+		signedStrike += 1n;
+	}
+	if (signedStrike > maxSafe) throw new PanopticError("deriveUniqueTokenId: exhausted strike space picking a unique tiny credit leg");
+	const encodedStrike = asset === 0n ? signedStrike : -signedStrike;
+	return {
+		index: legIndex,
+		asset,
+		tokenType,
+		optionRatio: 1n,
+		isLong: 1n,
+		riskPartner: legIndex,
+		strike: encodedStrike,
+		width: 0n
+	};
 }
-/** Wrap ETH and wait for confirmation. */
-async function wrapEthAndWait(params) {
-	const result = await wrapEth(params);
-	return result.wait();
+function appendTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing) {
+	const newLeg = pickUniqueTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing);
+	return addLegToTokenId(baseTokenId, newLeg);
+}
+function scaleRatios(baseTokenId, targetPositionSize) {
+	const legs = decodeAllLegs(baseTokenId);
+	const maxRatio = legs.reduce((m, leg) => leg.optionRatio > m ? leg.optionRatio : m, 0n);
+	const N = MAX_OPTION_RATIO / maxRatio;
+	if (N < 2n) throw new PanopticError("deriveUniqueTokenId: cannot derive a unique tokenId — all 4 leg slots used and optionRatios already near the 127 ceiling");
+	const newPositionSize = (targetPositionSize + N - 1n) / N;
+	const poolId = baseTokenId & POOL_ID_MASK$2;
+	let out = poolId;
+	for (const leg of legs) out = addLegToTokenId(out, {
+		index: leg.index,
+		asset: leg.asset,
+		tokenType: leg.tokenType,
+		optionRatio: leg.optionRatio * N,
+		isLong: leg.isLong ? 1n : 0n,
+		riskPartner: leg.riskPartner,
+		strike: leg.strike,
+		width: leg.width
+	});
+	return {
+		newTokenId: out,
+		newPositionSize,
+		effectivePositionSize: newPositionSize * N,
+		strategy: "ratio-scale"
+	};
 }
 /**
-* Unwrap WETH back into native ETH (`withdraw`). Burns the caller's own WETH —
-* no approval needed.
+* Derive a tokenId unique from `baseTokenId` for a partial reduction.
 *
-* @returns TxResult with hash and wait function
+* Prefers a tiny-credit-leg extension (arbitrary new size). Falls back to
+* optionRatio scaling only when the base tokenId already occupies all 4 leg
+* slots.
 */
-async function unwrapWeth(params) {
-	const { client, walletClient, account, weth, amount, txOverrides } = params;
-	return submitWrite({
-		client,
-		walletClient,
-		account,
-		address: weth,
-		abi: wethWrapAbi,
-		functionName: "withdraw",
-		args: [amount],
-		txOverrides
-	});
+function deriveUniqueTokenId(params) {
+	const { baseTokenId, targetPositionSize, tickSpacing = DEFAULT_TICK_SPACING } = params;
+	if (targetPositionSize <= 0n) throw new PanopticError("deriveUniqueTokenId: targetPositionSize must be > 0");
+	const legCount = countLegs(baseTokenId);
+	if (legCount === 0n) throw new PanopticError("deriveUniqueTokenId: baseTokenId has no legs");
+	if (legCount < MAX_LEGS) {
+		const newTokenId = appendTinyCreditLeg(baseTokenId, legCount, targetPositionSize, tickSpacing);
+		return {
+			newTokenId,
+			newPositionSize: targetPositionSize,
+			effectivePositionSize: targetPositionSize,
+			strategy: "tiny-credit"
+		};
+	}
+	return scaleRatios(baseTokenId, targetPositionSize);
 }
-/** Unwrap WETH and wait for confirmation. */
-async function unwrapWethAndWait(params) {
-	const result = await unwrapWeth(params);
-	return result.wait();
+/**
+* Re-export decoded leg count so callers can gate UI on the strategy that
+* would be chosen (e.g. show a divisibility hint on ratio-scale positions).
+*/
+function planDeriveStrategy(baseTokenId) {
+	return countLegs(baseTokenId) < MAX_LEGS ? "tiny-credit" : "ratio-scale";
 }
 
 //#endregion
-//#region src/panoptic/v2/tokenId/decode.ts
-/**
-* Convert a DecodedLeg to TokenIdLeg format.
-*
-* @param leg - The decoded leg from encoding utils
-* @param tickSpacing - The tick spacing for calculating tick bounds
-* @returns The TokenIdLeg format
-*/
-function convertToTokenIdLeg(leg, tickSpacing) {
-	const halfWidth = leg.width * tickSpacing / 2n;
-	const tickLower = leg.strike - halfWidth;
-	const tickUpper = leg.strike + halfWidth;
+//#region src/panoptic/v2/tokenId/generateOverlapping.ts
+const MAX_UINT64 = (1n << 64n) - 1n;
+const MAX_UINT128$2 = (1n << 128n) - 1n;
+const Q192 = 1n << 192n;
+const MAX_TOKEN_DECIMALS = 255n;
+const MAX_DECIMAL_EXPONENT = 512n;
+function invalid$1(message) {
+	throw new PanopticValidationError(`generateOverlappingTokenIds: ${message}`);
+}
+function pow10(exponent) {
+	return 10n ** exponent;
+}
+function parsePriceSpacing(value, quoteDecimals) {
+	const match = /^\+?(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:e([+-]?\d+))?$/i.exec(value.trim());
+	if (match === null) invalid$1("strikePriceSpacing must be a positive decimal string");
+	const integerPart = match[1] ?? "0";
+	const fractionalPart = match[2] ?? match[3] ?? "";
+	const exponent = BigInt(match[4] ?? "0");
+	if (exponent < -MAX_DECIMAL_EXPONENT || exponent > MAX_DECIMAL_EXPONENT) invalid$1("strikePriceSpacing exponent is too large");
+	let units = BigInt(`${integerPart}${fractionalPart}`);
+	let scale = BigInt(fractionalPart.length) - exponent;
+	if (scale < 0n) {
+		units *= pow10(-scale);
+		scale = 0n;
+	}
+	while (scale > 0n && units % 10n === 0n) {
+		units /= 10n;
+		scale -= 1n;
+	}
+	if (units <= 0n) invalid$1("strikePriceSpacing must be positive");
+	if (scale > quoteDecimals) invalid$1("strikePriceSpacing exceeds the quote token decimal precision");
 	return {
-		index: leg.index,
-		asset: leg.asset,
-		optionRatio: leg.optionRatio,
-		isLong: leg.isLong,
-		tokenType: leg.tokenType,
-		riskPartner: leg.riskPartner,
-		strike: leg.strike,
-		width: leg.width,
-		tickLower,
-		tickUpper
+		units,
+		scale,
+		denominator: pow10(scale)
 	};
 }
-/**
-* Decode a TokenId into its component parts.
-*
-* @param tokenId - The TokenId to decode
-* @returns The decoded TokenId data
-*
-* @example
-* ```typescript
-* const decoded = decodeTokenId(tokenId)
-* console.log(decoded.legs) // Array of legs
-* console.log(decoded.tickSpacing) // Tick spacing
-* ```
-*/
-function decodeTokenId(tokenId) {
-	const poolId = decodePoolId(tokenId);
-	const vegoid = decodeVegoid(tokenId);
-	const tickSpacing = decodeTickSpacing(tokenId);
-	const rawLegs = decodeAllLegs(tokenId);
-	const numLegs = countLegs(tokenId);
-	const legs = rawLegs.map((leg) => convertToTokenIdLeg(leg, tickSpacing));
+function formatGridPrice(multiple, spacing) {
+	const scaledPrice = multiple * spacing.units;
+	if (spacing.scale === 0n) return scaledPrice.toString();
+	const scale = Number(spacing.scale);
+	const digits = scaledPrice.toString().padStart(scale + 1, "0");
+	const decimalIndex = digits.length - scale;
+	return `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+}
+function quotePriceAtTick(tick, asset, assetDecimals, quoteDecimals) {
+	const orientedTick = asset === 0n ? tick : -tick;
+	const sqrtPriceX96 = tickToSqrtPriceX96(orientedTick);
+	let numerator = sqrtPriceX96 * sqrtPriceX96;
+	let denominator = Q192;
+	const decimalDifference = assetDecimals - quoteDecimals;
+	if (decimalDifference > 0n) numerator *= pow10(decimalDifference);
+	else if (decimalDifference < 0n) denominator *= pow10(-decimalDifference);
 	return {
-		tokenId,
-		poolId,
-		vegoid,
-		tickSpacing,
-		legs,
-		legCount: numLegs
+		numerator,
+		denominator
 	};
 }
-/**
-* Validate that a TokenId has the expected pool ID.
-*
-* @param tokenId - The TokenId to validate
-* @param expectedPoolId - The expected pool ID
-* @returns True if the pool IDs match
-*/
-function validatePoolId(tokenId, expectedPoolId) {
-	const actualPoolId = tokenId & (1n << 64n) - 1n;
-	return actualPoolId === expectedPoolId;
+function isPriceGridStrike(strike, params, spacing, tickSpacing) {
+	const price = quotePriceAtTick(strike, params.asset, params.assetDecimals, params.quoteDecimals);
+	const floorMultiple = price.numerator * spacing.denominator / (price.denominator * spacing.units);
+	for (const multiple of [floorMultiple, floorMultiple + 1n]) {
+		if (multiple <= 0n) continue;
+		const orientedTick = priceToTick(formatGridPrice(multiple, spacing), params.assetDecimals, params.quoteDecimals);
+		const poolTick = params.asset === 0n ? orientedTick : -orientedTick;
+		if (roundToTickSpacing(poolTick, tickSpacing) === strike) return true;
+	}
+	return false;
+}
+function ceilDiv$1(value, divisor) {
+	const quotient = value / divisor;
+	const remainder = value % divisor;
+	return remainder > 0n ? quotient + 1n : quotient;
+}
+function floorDiv(value, divisor) {
+	const quotient = value / divisor;
+	const remainder = value % divisor;
+	return remainder < 0n ? quotient - 1n : quotient;
+}
+function resolveLegs(legs) {
+	if (legs.length === 0 || legs.length > Number(TOKEN_ID_BITS.MAX_LEGS)) invalid$1("legs must contain between 1 and 4 entries");
+	const resolved = legs.map((leg, index) => {
+		if (leg.optionType !== "call" && leg.optionType !== "put") invalid$1(`leg ${index} has an invalid optionType`);
+		if (typeof leg.isLong !== "boolean") invalid$1(`leg ${index} has an invalid isLong value`);
+		if (leg.optionRatio < 1n || leg.optionRatio > LEG_LIMITS.MAX_RATIO) invalid$1(`leg ${index} optionRatio must be between 1 and ${LEG_LIMITS.MAX_RATIO}`);
+		const riskPartner = leg.riskPartner ?? BigInt(index);
+		if (riskPartner < 0n || riskPartner >= BigInt(legs.length)) invalid$1(`leg ${index} references an inactive risk partner`);
+		return {
+			...leg,
+			riskPartner
+		};
+	});
+	for (const [index, leg] of resolved.entries()) {
+		if (leg.riskPartner === BigInt(index)) continue;
+		const partner = resolved[Number(leg.riskPartner)];
+		if (partner === void 0 || partner.riskPartner !== BigInt(index)) invalid$1(`leg ${index} has a non-mutual risk partner`);
+	}
+	return resolved;
+}
+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 strikes = [];
+	for (let strike = firstStrike; strike <= lastStrike; strike += tickSpacing) if (isPriceGridStrike(strike, params, spacing, tickSpacing)) strikes.push(strike);
+	if (params.asset === 1n) strikes.reverse();
+	return strikes;
+}
+function buildTokenId$1(poolId, strike, width, asset, legs) {
+	const builder = createTokenIdBuilder(poolId);
+	for (const leg of legs) {
+		const config = {
+			strike,
+			width,
+			optionRatio: leg.optionRatio,
+			isLong: leg.isLong,
+			riskPartner: leg.riskPartner,
+			asset
+		};
+		if (leg.optionType === "call") builder.addCall(config);
+		else builder.addPut(config);
+	}
+	return builder.build();
 }
-/**
-* Check if a TokenId represents a long position (any leg is long).
-*
-* @param tokenId - The TokenId to check
-* @returns True if any leg is long
-*/
-function hasLongLeg(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	return legs.some((leg) => leg.isLong);
+function dividePositionSize$1(positionSize, count) {
+	if (positionSize < count) invalid$1(`positionSize ${positionSize} is too small for ${count} nonzero positions`);
+	const quotient = positionSize / count;
+	const remainder = positionSize % count;
+	const sizes = [];
+	for (let index = 0n; index < count; index += 1n) sizes.push(quotient + (index < remainder ? 1n : 0n));
+	return sizes;
 }
 /**
-* Check if a TokenId represents a short-only position.
-*
-* @param tokenId - The TokenId to check
-* @returns True if all legs are short
+* Generate a fixed quote-price lattice of co-strike TokenIds whose liquidity
+* ranges strictly contain the current tick. Returned arrays are ordered by
+* ascending quote strike price and are ready for `dispatch()`.
 */
-function isShortOnly(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	return legs.length > 0 && legs.every((leg) => !leg.isLong);
+function generateOverlappingTokenIds(params) {
+	if (params.poolId < 0n || params.poolId > MAX_UINT64) invalid$1("poolId must fit in uint64");
+	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$2) invalid$1("positionSize must be between 1 and uint128.max");
+	const tickSpacing = decodeTickSpacing$1(params.poolId);
+	if (tickSpacing <= 0n) invalid$1("poolId tick spacing must be positive");
+	const standardTickWidth = STANDARD_TICK_WIDTHS[params.timescale];
+	if (standardTickWidth === void 0) invalid$1(`unknown timescale ${String(params.timescale)}`);
+	const width = (standardTickWidth + tickSpacing - 1n) / tickSpacing;
+	if (width <= 0n || width > LEG_LIMITS.MAX_WIDTH) invalid$1(`timescale width does not fit in the TokenId width field for tick spacing ${tickSpacing}`);
+	const halfWidth = width * tickSpacing / 2n;
+	if (halfWidth <= 0n) invalid$1("timescale width must span at least two ticks");
+	const spacing = parsePriceSpacing(params.strikePriceSpacing, params.quoteDecimals);
+	const legs = resolveLegs(params.legs);
+	const strikes = getCandidateStrikes(params, spacing, tickSpacing, halfWidth);
+	if (strikes.length === 0) invalid$1("no price-grid strikes overlap the current tick");
+	return {
+		positionIdList: strikes.map((strike) => buildTokenId$1(params.poolId, strike, width, params.asset, legs)),
+		positionSizes: dividePositionSize$1(params.positionSize, BigInt(strikes.length))
+	};
 }
-/**
-* Check if a TokenId represents a spread (legs with different risk partners).
-*
-* @param tokenId - The TokenId to check
-* @returns True if any leg has a different risk partner
-*/
-function isSpread(tokenId) {
+
+//#endregion
+//#region src/panoptic/v2/tokenId/split.ts
+const POOL_ID_MASK$1 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+const MAX_UINT128$1 = (1n << 128n) - 1n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+function invalid(message) {
+	throw new PanopticValidationError(`splitTokenIdByTimescale: ${message}`);
+}
+function validateInput(tokenId, positionSize) {
+	if (tokenId < 0n || tokenId > MAX_UINT256) invalid("tokenId must fit in uint256");
+	if (positionSize <= 0n || positionSize > MAX_UINT128$1) invalid("positionSize must be between 1 and uint128.max");
 	const legs = decodeAllLegs(tokenId);
-	return legs.some((leg) => leg.riskPartner !== leg.index);
+	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");
+	const firstUnusedBit = TOKEN_ID_BITS.POOL_ID_SIZE + BigInt(legs.length) * TOKEN_ID_BITS.LEG_SIZE;
+	if (tokenId >> firstUnusedBit !== 0n) invalid("inactive leg slots must be empty");
+	const byIndex = new Map(legs.map((leg) => [leg.index, leg]));
+	for (const leg of legs) {
+		const partner = byIndex.get(leg.riskPartner);
+		if (partner === void 0) invalid(`leg ${leg.index} references an inactive risk partner`);
+		if (partner.index !== leg.index && partner.riskPartner !== leg.index) invalid(`leg ${leg.index} has a non-mutual risk partner`);
+	}
+	return legs;
 }
-/**
-* Get the asset index for a TokenId (from the first leg).
-*
-* @param tokenId - The TokenId
-* @returns The asset index (0 or 1), or undefined if no legs
-*/
-function getAssetIndex(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	if (legs.length === 0) return void 0;
-	return legs[0].asset;
+function isCall(leg) {
+	return leg.tokenType === leg.asset;
+}
+function isEconomicStraddlePair(left, right) {
+	return isCall(left) !== isCall(right) && left.asset === right.asset && left.optionRatio === right.optionRatio && left.isLong === right.isLong && left.strike === right.strike && left.width === right.width;
+}
+/** Preserve mutual pairs, then pair self-partnered economic straddles in source order. */
+function groupOptionLegs(optionLegs) {
+	const byIndex = new Map(optionLegs.map((leg) => [leg.index, leg]));
+	const consumed = new Set();
+	const groups = [];
+	for (const leg of optionLegs) {
+		if (consumed.has(leg.index)) continue;
+		if (leg.riskPartner !== leg.index) {
+			const riskPartner = byIndex.get(leg.riskPartner);
+			if (riskPartner === void 0) invalid(`mutual risk pair containing leg ${leg.index} cannot be separated`);
+			consumed.add(leg.index);
+			consumed.add(riskPartner.index);
+			groups.push([leg, riskPartner]);
+			continue;
+		}
+		const partner = optionLegs.find((candidate) => candidate.index > leg.index && !consumed.has(candidate.index) && candidate.riskPartner === candidate.index && isEconomicStraddlePair(leg, candidate));
+		consumed.add(leg.index);
+		if (partner === void 0) {
+			groups.push([leg]);
+			continue;
+		}
+		consumed.add(partner.index);
+		groups.push([leg, partner]);
+	}
+	return groups;
+}
+function remapRiskPartner(leg, indexBySource) {
+	const riskPartner = indexBySource.get(leg.riskPartner);
+	if (riskPartner === void 0) invalid(`risk partner for leg ${leg.index} is missing from its output group`);
+	return riskPartner;
+}
+function buildTokenId(poolId, legs, transform) {
+	const indexBySource = new Map(legs.map((leg, index) => [leg.index, BigInt(index)]));
+	let output = poolId;
+	for (const [index, leg] of legs.entries()) {
+		const newIndex = BigInt(index);
+		const { strike, width } = transform(leg);
+		if (strike < LEG_LIMITS.MIN_STRIKE || strike > LEG_LIMITS.MAX_STRIKE) invalid(`generated strike ${strike} does not fit in int24`);
+		if (width < 0n || width > LEG_LIMITS.MAX_WIDTH) invalid(`generated width ${width} does not fit in the TokenId width field`);
+		output = addLegToTokenId(output, {
+			index: newIndex,
+			asset: leg.asset,
+			optionRatio: leg.optionRatio,
+			isLong: leg.isLong ? 1n : 0n,
+			tokenType: leg.tokenType,
+			riskPartner: remapRiskPartner(leg, indexBySource),
+			strike,
+			width
+		});
+	}
+	return output;
+}
+function childWidths(sourceWidth, targetWidth) {
+	if (sourceWidth <= targetWidth) return [sourceWidth];
+	const fullWidthCount = sourceWidth / targetWidth;
+	const remainder = sourceWidth % targetWidth;
+	const widths = [];
+	for (let remaining = fullWidthCount; remaining > 0n; remaining -= 1n) widths.push(targetWidth);
+	if (remainder > 0n) widths.push(remainder);
+	return widths;
+}
+function dividePositionSize(positionSize, count) {
+	const countBigInt = BigInt(count);
+	if (positionSize < countBigInt) invalid(`positionSize ${positionSize} is too small for ${count} nonzero child positions`);
+	const quotient = positionSize / countBigInt;
+	const remainder = positionSize % countBigInt;
+	return Array.from({ length: count }, (_, index) => quotient + (BigInt(index) < remainder ? 1n : 0n));
+}
+function splitGroup(poolId, group, tickSpacing, targetWidth, positionSize) {
+	const sourceWidth = group[0]?.width;
+	if (sourceWidth === void 0 || sourceWidth === 0n) invalid("option group must have nonzero width");
+	if (group.some((leg) => leg.width !== sourceWidth)) invalid("all legs in an option group must have the same width");
+	const widths = childWidths(sourceWidth, targetWidth);
+	const positionSizes = dividePositionSize(positionSize, widths.length);
+	let consumedWidth = 0n;
+	const positionIdList = widths.map((width) => {
+		const offset = consumedWidth;
+		consumedWidth += width;
+		return buildTokenId(poolId, group, (leg) => {
+			const sourceLower = leg.strike - sourceWidth * tickSpacing / 2n;
+			const childLower = sourceLower + offset * tickSpacing;
+			const strike = childLower + width * tickSpacing / 2n;
+			return {
+				strike,
+				width
+			};
+		});
+	});
+	return {
+		positionIdList,
+		positionSizes
+	};
 }
 /**
-* Check if a leg is a loan (width=0 and isLong=false).
-*
-* Loans borrow liquidity from the pool at a specific strike price.
+* Split every standalone option, economic straddle, or mutual risk pair in a
+* TokenId into a shorter standard timescale. Width-zero credit/loan legs are
+* emitted together as one final position. Returned arrays are parallel and
+* ready for `dispatch()`.
 *
-* @param leg - The decoded leg to check
-* @returns True if the leg is a loan
+* Each option group divides `positionSize` independently across its children.
+* Integer remainder units are assigned to the lower children first.
 */
-function isLoanLeg(leg) {
-	return leg.width === 0n && !leg.isLong;
+function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
+	const legs = validateInput(tokenId, positionSize);
+	const tickSpacing = decodeTickSpacing$1(tokenId);
+	if (tickSpacing <= 0n) invalid("tokenId tick spacing must be positive");
+	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$1;
+	const optionLegs = legs.filter((leg) => leg.width > 0n);
+	const fundingLegs = legs.filter((leg) => leg.width === 0n);
+	const positionIdList = [];
+	const positionSizes = [];
+	for (const group of groupOptionLegs(optionLegs)) {
+		const split = splitGroup(poolId, group, tickSpacing, targetWidth, positionSize);
+		positionIdList.push(...split.positionIdList);
+		positionSizes.push(...split.positionSizes);
+	}
+	if (fundingLegs.length > 0) {
+		positionIdList.push(buildTokenId(poolId, fundingLegs, (leg) => ({
+			strike: leg.strike,
+			width: leg.width
+		})));
+		positionSizes.push(positionSize);
+	}
+	return {
+		positionIdList,
+		positionSizes
+	};
 }
-/**
-* Check if a leg is a credit (width=0 and isLong=true).
-*
-* Credits lend liquidity to the pool at a specific strike price.
-*
-* @param leg - The decoded leg to check
-* @returns True if the leg is a credit
-*/
-function isCreditLeg(leg) {
-	return leg.width === 0n && leg.isLong;
+
+//#endregion
+//#region src/panoptic/v2/writes/protectedSettle.ts
+const POOL_ID_MASK = (1n << 64n) - 1n;
+const Q96 = 1n << 96n;
+const MAX_UINT128 = (1n << 128n) - 1n;
+const SETTLE_LIMITS = [
+	-887272n,
+	887272n,
+	0n
+];
+function ceilDiv(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(delta, liquidityFactor);
+		const legSize = ceilDiv(requiredAmount, leg.optionRatio);
+		if (legSize > requiredSize) requiredSize = legSize;
+	}
+	if (requiredSize > MAX_UINT128) 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
+		});
+	});
+	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;
+	});
+	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$1(sourceTokenId));
+				if (size !== void 0) return {
+					tokenId,
+					size
+				};
+			}
+		}
+	}
+	throw new PanopticError("Unable to derive a collision-free protected settlement poke");
 }
 /**
-* Check if a TokenId is a pure loan (all legs are loans).
-*
-* @param tokenId - The TokenId to check
-* @returns True if all legs are loans
+* Build `[poke, settle, poke]` for every target containing a width>0 short.
+* Pure-long and width-zero positions are settled directly.
 */
-function isLoan(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	return legs.length > 0 && legs.every(isLoanLeg);
+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
+	};
 }
 /**
-* Check if a TokenId is a pure credit (all legs are credits).
+* Build the atomic self-settlement dispatch that temporarily pokes each
+* affected short chunk before settling its source position.
 *
-* @param tokenId - The TokenId to check
-* @returns True if all legs are credits
+* @param params - Positions, current sizes, and complete held-position list.
+* @returns A dispatch intent ready for simulation or submission.
 */
-function isCredit(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	return legs.length > 0 && legs.every(isCreditLeg);
+function buildProtectedSettleDispatch(params) {
+	return buildProtectedSettlePlan(params).dispatch;
 }
+
+//#endregion
+//#region src/panoptic/v2/reads/positionSizes.ts
+const BIT_MASK_128$1 = (1n << 128n) - 1n;
 /**
-* Check if a TokenId contains loan or credit legs (width=0).
-*
-* @param tokenId - The TokenId to check
-* @returns True if any leg has width=0 (loan or credit)
+* Returns the current stored positionSize for each tokenId, in the same order
+* as the input `positionIdList`. Reverts (via the contract) if any tokenId is
+* not held by `account`.
 */
-function hasLoanOrCredit(tokenId) {
-	const legs = decodeAllLegs(tokenId);
-	return legs.some((leg) => leg.width === 0n);
+async function getCurrentPositionSizes(params) {
+	const { client, poolAddress, account, positionIdList, blockNumber } = params;
+	if (positionIdList.length === 0) return [];
+	const [, , positionBalances] = await client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			false,
+			positionIdList
+		],
+		blockNumber
+	});
+	return positionBalances.map((packed) => packed & BIT_MASK_128$1);
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/tokenFlow.ts
-/**
-* PanopticPool getAssetsOf ABI.
-* Returns collateral assets (shares converted to underlying) for an account.
-*/
-const getAssetsOfAbi = [{
-	type: "function",
-	name: "getAssetsOf",
-	inputs: [{
-		name: "account",
-		type: "address"
-	}],
-	outputs: [{
-		name: "assets0",
-		type: "uint256"
-	}, {
-		name: "assets1",
-		type: "uint256"
-	}],
-	stateMutability: "view"
-}];
-/**
-* PanopticPool multicall ABI (inherited from Uniswap).
-* Uses delegatecall, preserving msg.sender throughout the chain.
-*/
-const multicallAbi = [{
-	type: "function",
-	name: "multicall",
-	inputs: [{
-		name: "data",
-		type: "bytes[]"
-	}],
-	outputs: [{
-		name: "results",
-		type: "bytes[]"
-	}],
-	stateMutability: "nonpayable"
-}, ...panopticErrorsAbi];
+//#region src/panoptic/v2/reads/premia.ts
 /**
-* Simulate a contract call and measure token flow using PanopticPool.multicall.
-*
-* This function uses PanopticPool's inherited multicall (delegatecall-based) to chain:
-* 1. getAssetsOf(user) - read collateral assets before
-* 2. getCurrentTick() - read pool tick before
-* 3. Execute the target call (e.g., dispatch)
-* 4. getCurrentTick() - read pool tick after
-* 5. getAssetsOf(user) - read collateral assets after
+* Get premia totals for an account.
 *
-* ## Why PanopticPool.multicall instead of Multicall3?
-* - Measures **collateral assets** (shares → underlying), not raw wallet balances
-* - Uses **delegatecall**, preserving msg.sender throughout the chain
-* - Single contract interaction with PanopticPool
-* - Correctly reflects what happens during position operations
-*
-* ## Same-Block Guarantee
-* All operations execute within a single eth_call, ensuring atomic consistency.
+* Returns the total short and long premium across all positions.
+* Short premium is owed TO the account (earned from selling options).
+* Long premium is owed BY the account (paid for buying options).
 *
-* @param params - Simulation parameters
-* @returns Token flow result
+* @param params - The parameters
+* @returns Premia totals with block metadata
 *
 * @example
 * ```typescript
-* const callData = encodeFunctionData({
-*   abi: panopticPoolV2Abi,
-*   functionName: 'dispatch',
-*   args: [positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, false, 0n],
-* })
-*
-* const result = await simulateWithTokenFlow({
+* const premia = await getAccountPremia({
 *   client,
 *   poolAddress,
-*   user: userAddress,
-*   callData,
+*   account,
+*   tokenIds: [tokenId1, tokenId2],
+*   includePendingPremium: true,
 * })
 *
-* if (result.success) {
-*   console.log('Token 0 change:', result.tokenFlow.delta0)
-*   console.log('Token 1 change:', result.tokenFlow.delta1)
-* }
+* console.log('Short premium earned:', premia.shortPremium0, premia.shortPremium1)
+* console.log('Long premium owed:', premia.longPremium0, premia.longPremium1)
+* ```
+*/
+async function getAccountPremia(params) {
+	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (tokenIds.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		return {
+			shortPremium0: 0n,
+			shortPremium1: 0n,
+			longPremium0: 0n,
+			longPremium1: 0n,
+			includePendingPremium,
+			_meta: _meta$1
+		};
+	}
+	const [[shortPremiumPacked, longPremiumPacked], _meta] = await Promise.all([client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			tokenIds
+		],
+		blockNumber: targetBlockNumber
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
+	const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
+	return {
+		shortPremium0: shortPremium.right,
+		shortPremium1: shortPremium.left,
+		longPremium0: longPremium.right,
+		longPremium1: longPremium.left,
+		includePendingPremium,
+		_meta
+	};
+}
+/**
+* Get positions with per-position premia data.
+*
+* Uses multicall to batch individual getFullPositionsData calls
+* for each position, giving us per-position premia in a single RPC request.
+*
+* @param params - The parameters
+* @returns Positions with premia and totals with block metadata
+*
+* @example
+* ```typescript
+* const result = await getPositionsWithPremia({
+*   client,
+*   poolAddress,
+*   account,
+*   tokenIds: [tokenId1, tokenId2],
+* })
+*
+* for (const position of result.positions) {
+*   console.log('Position:', position.tokenId)
+*   console.log('Premia:', position.premiaOwed0, position.premiaOwed1)
+* }
+* console.log('Total short premium:', result.shortPremium0, result.shortPremium1)
+* ```
+*/
+async function getPositionsWithPremia(params) {
+	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (tokenIds.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		return {
+			positions: [],
+			shortPremium0: 0n,
+			shortPremium1: 0n,
+			longPremium0: 0n,
+			longPremium1: 0n,
+			includePendingPremium,
+			_meta: _meta$1
+		};
+	}
+	const contracts = tokenIds.map((tokenId) => ({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			[tokenId]
+		]
+	}));
+	const [multicallResults, _meta] = await Promise.all([client.multicall({
+		contracts,
+		blockNumber: targetBlockNumber,
+		allowFailure: true
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const positions = [];
+	let totalShortPremium0 = 0n;
+	let totalShortPremium1 = 0n;
+	let totalLongPremium0 = 0n;
+	let totalLongPremium1 = 0n;
+	for (let i = 0; i < tokenIds.length; i++) {
+		const tokenId = tokenIds[i];
+		const result = multicallResults[i];
+		if (result.status !== "success") continue;
+		const [shortPremiumPacked, longPremiumPacked, balances] = result.result;
+		const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
+		const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
+		totalShortPremium0 += shortPremium.right;
+		totalShortPremium1 += shortPremium.left;
+		totalLongPremium0 += longPremium.right;
+		totalLongPremium1 += longPremium.left;
+		const balanceData = balances[0];
+		if (balanceData === void 0) continue;
+		const positionSize = balanceData & (1n << 128n) - 1n;
+		if (positionSize === 0n) continue;
+		const poolUtilization0 = balanceData >> 128n & 0xffffn;
+		const poolUtilization1 = balanceData >> 144n & 0xffffn;
+		let tickAtMint = balanceData >> 160n & 0xffffffn;
+		if (tickAtMint > 0x7fffffn) tickAtMint = tickAtMint - 0x1000000n;
+		const timestampAtMint = balanceData >> 184n & 0xffffffffn;
+		const blockAtMint = balanceData >> 216n & (1n << 39n) - 1n;
+		const swapAtMint = balanceData >> 255n === 1n;
+		const decoded = decodePosition(tokenId);
+		const tickSpacing = decodeTickSpacing(tokenId);
+		const legs = decoded.legs.map((leg) => {
+			const width = leg.width;
+			const strike = leg.strike;
+			const tickLower = strike - width * tickSpacing / 2n;
+			const tickUpper = strike + width * tickSpacing / 2n;
+			return {
+				index: BigInt(leg.index),
+				asset: leg.asset,
+				optionRatio: leg.optionRatio,
+				isLong: leg.isLong === 1n,
+				tokenType: leg.tokenType,
+				riskPartner: leg.riskPartner,
+				strike,
+				width,
+				tickLower,
+				tickUpper
+			};
+		});
+		const premiaOwed0 = shortPremium.right - longPremium.right;
+		const premiaOwed1 = shortPremium.left - longPremium.left;
+		positions.push({
+			tokenId,
+			positionSize,
+			owner: account,
+			poolAddress,
+			legs,
+			poolUtilization0AtMint: poolUtilization0,
+			poolUtilization1AtMint: poolUtilization1,
+			tickAtMint,
+			timestampAtMint,
+			blockNumberAtMint: blockAtMint,
+			swapAtMint,
+			premiaOwed0,
+			premiaOwed1,
+			assetIndex: legs.length > 0 ? legs[0].asset : 0n,
+			_meta
+		});
+	}
+	return {
+		positions,
+		shortPremium0: totalShortPremium0,
+		shortPremium1: totalShortPremium1,
+		longPremium0: totalLongPremium0,
+		longPremium1: totalLongPremium1,
+		includePendingPremium,
+		_meta
+	};
+}
+/**
+* Get the unsettled short premium an account would forfeit by closing now.
+*
+* Calls `getFullPositionsData` twice in one multicall — once with
+* `includePendingPremium = true` (everything owed to the short legs) and once
+* with `false` (only what is available to collect). The difference is the
+* premium still owed by buyers that has not been settled; closing before it
+* settles forfeits it. Settling buyers first (see `settlePremiumFrom`) moves
+* that premium into the available bucket.
+*
+* @param params - The parameters
+* @returns Owed, available, and forfeitable premium with block metadata
+*/
+async function getForfeitablePremium(params) {
+	const { client, poolAddress, account, tokenIds, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const contracts = [true, false].map((includePendingPremium) => ({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			tokenIds
+		]
+	}));
+	const [multicallResults, _meta] = await Promise.all([client.multicall({
+		contracts,
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const owed = decodeLeftRightUnsigned(multicallResults[0][0]);
+	const available = decodeLeftRightUnsigned(multicallResults[1][0]);
+	const forfeit0 = owed.right > available.right ? owed.right - available.right : 0n;
+	const forfeit1 = owed.left > available.left ? owed.left - available.left : 0n;
+	return {
+		owed0: owed.right,
+		owed1: owed.left,
+		available0: available.right,
+		available1: available.left,
+		forfeit0,
+		forfeit1,
+		_meta
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/simulations/tokenFlow.ts
+/**
+* PanopticPool getAssetsOf ABI.
+* Returns collateral assets (shares converted to underlying) for an account.
+*/
+const getAssetsOfAbi = [{
+	type: "function",
+	name: "getAssetsOf",
+	inputs: [{
+		name: "account",
+		type: "address"
+	}],
+	outputs: [{
+		name: "assets0",
+		type: "uint256"
+	}, {
+		name: "assets1",
+		type: "uint256"
+	}],
+	stateMutability: "view"
+}];
+/**
+* PanopticPool multicall ABI (inherited from Uniswap).
+* Uses delegatecall, preserving msg.sender throughout the chain.
+*/
+const multicallAbi$1 = [{
+	type: "function",
+	name: "multicall",
+	inputs: [{
+		name: "data",
+		type: "bytes[]"
+	}],
+	outputs: [{
+		name: "results",
+		type: "bytes[]"
+	}],
+	stateMutability: "nonpayable"
+}, ...panopticErrorsAbi];
+/**
+* Simulate a contract call and measure token flow using PanopticPool.multicall.
+*
+* This function uses PanopticPool's inherited multicall (delegatecall-based) to chain:
+* 1. getAssetsOf(user) - read collateral assets before
+* 2. getCurrentTick() - read pool tick before
+* 3. Execute the target call (e.g., dispatch)
+* 4. getCurrentTick() - read pool tick after
+* 5. getAssetsOf(user) - read collateral assets after
+*
+* ## Why PanopticPool.multicall instead of Multicall3?
+* - Measures **collateral assets** (shares → underlying), not raw wallet balances
+* - Uses **delegatecall**, preserving msg.sender throughout the chain
+* - Single contract interaction with PanopticPool
+* - Correctly reflects what happens during position operations
+*
+* ## Same-Block Guarantee
+* All operations execute within a single eth_call, ensuring atomic consistency.
+*
+* @param params - Simulation parameters
+* @returns Token flow result
+*
+* @example
+* ```typescript
+* const callData = encodeFunctionData({
+*   abi: panopticPoolV2Abi,
+*   functionName: 'dispatch',
+*   args: [positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, false, 0n],
+* })
+*
+* const result = await simulateWithTokenFlow({
+*   client,
+*   poolAddress,
+*   user: userAddress,
+*   callData,
+* })
+*
+* if (result.success) {
+*   console.log('Token 0 change:', result.tokenFlow.delta0)
+*   console.log('Token 1 change:', result.tokenFlow.delta1)
+* }
 * ```
 */
 async function simulateWithTokenFlow(params) {
@@ -3003,7 +3561,7 @@ async function simulateWithTokenFlow(params) {
 	try {
 		const { result } = await client.simulateContract({
 			address: poolAddress,
-			abi: multicallAbi,
+			abi: multicallAbi$1,
 			functionName: "multicall",
 			args: [multicallData],
 			account: user,
@@ -3131,6 +3689,1359 @@ async function getPoolTokensForSimulation(params) {
 	};
 }
 
+//#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)"
+	}
+];
+/**
+* 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).
+*
+* @param params - Simulation parameters
+* @returns Simulation result with settled premium data or error
+*/
+async function simulateSettlePremiumFrom(params) {
+	const { client, poolAddress, account, user, positionIdListFrom, positionIdList, tokenId, 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
+	};
+	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
+*
+* @example
+* ```typescript
+* // Speed up with default 12.5% bump
+* const result = await speedUpTransaction({
+*   client,
+*   walletClient,
+*   hash: pendingTxHash,
+* })
+*
+* // Speed up with explicit gas prices
+* const result = await speedUpTransaction({
+*   client,
+*   walletClient,
+*   hash: pendingTxHash,
+*   maxFeePerGas: 50_000_000_000n, // 50 gwei
+*   maxPriorityFeePerGas: 3_000_000_000n, // 3 gwei
+* })
+* ```
+*/
+async function speedUpTransaction(params) {
+	const { client, walletClient, hash, maxFeePerGas: explicitMaxFee, maxPriorityFeePerGas: explicitMaxPriority, gasPriceMultiplier = DEFAULT_GAS_PRICE_MULTIPLIER, broadcaster } = params;
+	const tx = await client.getTransaction({ hash });
+	const { maxFeePerGas, maxPriorityFeePerGas } = computeBumpedGas(tx.maxFeePerGas ?? void 0, tx.maxPriorityFeePerGas ?? void 0, explicitMaxFee, explicitMaxPriority, gasPriceMultiplier);
+	if (broadcaster) {
+		const request = await walletClient.prepareTransactionRequest({
+			account: tx.from,
+			to: tx.to ?? void 0,
+			data: tx.input,
+			value: tx.value,
+			nonce: tx.nonce,
+			gas: tx.gas,
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+			chain: walletClient.chain
+		});
+		const signedTx = await walletClient.signTransaction({
+			...request,
+			account: tx.from
+		});
+		const replacementHash$1 = await broadcaster.broadcast(signedTx);
+		return createTxResult(client, replacementHash$1);
+	}
+	const replacementHash = await walletClient.sendTransaction({
+		account: tx.from,
+		to: tx.to ?? void 0,
+		data: tx.input,
+		value: tx.value,
+		nonce: tx.nonce,
+		gas: tx.gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		chain: walletClient.chain
+	});
+	return createTxResult(client, replacementHash);
+}
+/**
+* Cancel a pending transaction by sending a 0-value self-transfer
+* with the same nonce and higher gas price.
+*
+* @param params - Cancel parameters
+* @returns TxResult for the cancellation transaction
+* @throws Error if the original transaction is not found
+*
+* @example
+* ```typescript
+* const result = await cancelTransaction({
+*   client,
+*   walletClient,
+*   account,
+*   hash: pendingTxHash,
+* })
+* await result.wait()
+* ```
+*/
+async function cancelTransaction(params) {
+	const { client, walletClient, account, hash, maxFeePerGas: explicitMaxFee, maxPriorityFeePerGas: explicitMaxPriority, gasPriceMultiplier = DEFAULT_GAS_PRICE_MULTIPLIER, broadcaster } = params;
+	const tx = await client.getTransaction({ hash });
+	const { maxFeePerGas, maxPriorityFeePerGas } = computeBumpedGas(tx.maxFeePerGas ?? void 0, tx.maxPriorityFeePerGas ?? void 0, explicitMaxFee, explicitMaxPriority, gasPriceMultiplier);
+	if (broadcaster) {
+		const request = await walletClient.prepareTransactionRequest({
+			account,
+			to: account,
+			value: 0n,
+			nonce: tx.nonce,
+			gas: 21000n,
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+			chain: walletClient.chain
+		});
+		const signedTx = await walletClient.signTransaction({
+			...request,
+			account
+		});
+		const cancelHash$1 = await broadcaster.broadcast(signedTx);
+		return createTxResult(client, cancelHash$1);
+	}
+	const cancelHash = await walletClient.sendTransaction({
+		account,
+		to: account,
+		value: 0n,
+		nonce: tx.nonce,
+		gas: 21000n,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		chain: walletClient.chain
+	});
+	return createTxResult(client, cancelHash);
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/loanUtils.ts
+/** Maximum retry attempts on InputListFail */
+const MAX_RETRIES = 3;
+/**
+* Resolve token index (0 or 1) for the given token address against the pool.
+* Throws SwapTokenMismatchError if the token isn't in the pool.
+*/
+function resolveTokenIndex(tokenAddress, token0, token1) {
+	const lower = tokenAddress.toLowerCase();
+	if (lower === token0.toLowerCase()) return 0n;
+	if (lower === token1.toLowerCase()) return 1n;
+	throw new SwapTokenMismatchError(tokenAddress, token0, token1);
+}
+/**
+* Resolve existing position IDs from explicit param or storage.
+*/
+async function resolvePositionIds(explicit, storage, chainId, poolAddress, account) {
+	if (explicit !== void 0) return explicit;
+	if (storage) return getTrackedPositionIds({
+		chainId,
+		poolAddress,
+		account,
+		storage
+	});
+	throw new MissingPositionIdsError();
+}
+/**
+* Check if a caught error is an InputListFail contract revert.
+* Works with both raw viem errors and parsed PanopticError instances.
+*/
+function isInputListFailError(error) {
+	if (error instanceof InputListFailError) return true;
+	const parsed = parsePanopticError(error);
+	return parsed?.errorName === "InputListFail";
+}
+/**
+* Build a unique width=0 tokenId that doesn't collide with existing positions.
+* Bumps optionRatio (1-127) and returns adjusted size to maintain equivalent exposure.
+*
+* @param kind - Whether to build a loan (borrow) or a credit (pay-in) leg.
+* @param asset - Which token denominates the positionSize (0 or 1).
+*/
+function buildUniqueWidthZeroLeg(kind, poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
+	const addLeg = (strike$1, optionRatio) => {
+		const builder = createTokenIdBuilder(poolId);
+		const config = {
+			asset,
+			tokenType,
+			strike: strike$1,
+			optionRatio
+		};
+		return (kind === "loan" ? builder.addLoan(config) : builder.addCredit(config)).build();
+	};
+	const mod = currentTick % tickSpacing;
+	let strike = currentTick - (mod + tickSpacing) % tickSpacing;
+	for (let ratio = 1n; ratio <= 127n; ratio++) {
+		const tokenId = addLeg(strike, ratio);
+		if (!existingPositionIds.includes(tokenId)) {
+			const adjustedSize = positionSize / ratio;
+			if (adjustedSize === 0n || positionSize % ratio !== 0n) continue;
+			return {
+				tokenId,
+				adjustedSize
+			};
+		}
+	}
+	const mod2 = currentTick % tickSpacing;
+	strike = currentTick - (mod2 + tickSpacing) % tickSpacing + tickSpacing;
+	for (let i = 0; i < 100; i++) {
+		const tokenId = addLeg(strike);
+		if (!existingPositionIds.includes(tokenId)) return {
+			tokenId,
+			adjustedSize: positionSize
+		};
+		strike += tickSpacing;
+	}
+	throw new LoanSlotExhaustedError();
+}
+/**
+* Build a unique loan (borrow) tokenId that doesn't collide with existing positions.
+*
+* @param asset - Which token denominates the positionSize (0 or 1).
+*/
+function buildUniqueLoan(poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
+	return buildUniqueWidthZeroLeg("loan", poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize);
+}
+/**
+* Build a unique credit (pay-in) tokenId that doesn't collide with existing positions.
+*
+* Unlike a loan, a credit never borrows from the pool: it requires **zero** buying
+* power, leaves `s_assetsInAMM` (and therefore utilization and the borrow rate)
+* untouched, and accrues no interest. This is what lets a credit-based swap run
+* against a fully-utilized collateral tracker.
+*
+* @param asset - Which token denominates the positionSize (0 or 1).
+*/
+function buildUniqueCredit(poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize) {
+	return buildUniqueWidthZeroLeg("credit", poolId, asset, tokenType, currentTick, tickSpacing, existingPositionIds, positionSize);
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/swap.ts
+/** Build an atomic credit mint/burn swap without fetching or sending anything. */
+function buildCreditSwapCall(params) {
+	const amount = params.kind === "exactIn" ? params.amountIn : params.amountOut;
+	if (amount <= 0n) throw new Error("credit swap amount must be positive");
+	if (params.tokenIndex !== 0n && params.tokenIndex !== 1n) throw new Error("credit swap tokenIndex must be 0 or 1");
+	const { low, high } = tickLimits(params.currentTick, params.slippageBps);
+	const { tokenId: creditTokenId, adjustedSize } = buildUniqueCredit(params.poolId, params.tokenIndex, params.tokenIndex, params.currentTick, params.tickSpacing, params.existingPositionIds, amount);
+	const ascending = [
+		Number(low),
+		Number(high),
+		0
+	];
+	const descending = [
+		Number(high),
+		Number(low),
+		0
+	];
+	const limits = params.kind === "exactIn" ? [ascending, descending] : [descending, ascending];
+	const args = [
+		[creditTokenId, creditTokenId],
+		[...params.existingPositionIds],
+		[adjustedSize, 0n],
+		limits,
+		false,
+		params.builderCode ?? 0n
+	];
+	return {
+		to: params.poolAddress,
+		data: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "dispatch",
+			args
+		}),
+		creditTokenId,
+		adjustedSize,
+		args
+	};
+}
+/**
+* Swap tokens using Panoptic's exact-output mechanism.
+*
+* Opens a credit in `tokenOut` with `swapAtMint=true` (paying a swapped amount of
+* the other token), then burns it with `swapAtMint=false` to receive exactly
+* `amountOut` of `tokenOut`.
+*
+* @param params - Swap parameters
+* @returns TxResult
+*
+* @example
+* ```typescript
+* const result = await swapExactOut({
+*   client, walletClient, account, poolAddress,
+*   chainId: 11155111n,
+*   tokenOut: WETH_ADDRESS,
+*   amountOut: 5n * 10n**16n,  // 0.05 WETH
+*   slippageBps: 500n,         // 5% slippage
+* })
+* const receipt = await result.wait()
+* ```
+*/
+async function swapExactOut(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenOut, amountOut, slippageBps, existingPositionIds: explicitIds, storage, builderCode = 0n, txOverrides } = params;
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+		const [pool, positionIds] = await Promise.all([getPool({
+			client,
+			poolAddress,
+			chainId
+		}), resolvePositionIds(explicitIds, storage, chainId, poolAddress, account)]);
+		const token0 = pool.collateralTracker0.token;
+		const token1 = pool.collateralTracker1.token;
+		const tokenOutIndex = resolveTokenIndex(tokenOut, token0, token1);
+		const call = buildCreditSwapCall({
+			kind: "exactOut",
+			poolAddress,
+			poolId: pool.poolId,
+			currentTick: pool.currentTick,
+			tickSpacing: pool.tickSpacing,
+			existingPositionIds: positionIds,
+			tokenIndex: tokenOutIndex,
+			amountOut,
+			slippageBps,
+			builderCode
+		});
+		try {
+			return await submitWrite({
+				client,
+				walletClient,
+				account,
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "dispatch",
+				args: call.args,
+				txOverrides
+			});
+		} catch (error) {
+			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
+			throw error;
+		}
+	}
+	throw new MaxRetriesExceededError("swapExactOut");
+}
+/**
+* Swap exact output and wait for confirmation.
+*/
+async function swapExactOutAndWait(params) {
+	const result = await swapExactOut(params);
+	return result.wait();
+}
+/**
+* Swap tokens using Panoptic's exact-input mechanism.
+*
+* Opens a credit in `tokenIn` with `swapAtMint=false` (paying exactly `amountIn`),
+* then burns it with `swapAtMint=true` to receive the swapped amount of the other
+* token. The user spends exactly `amountIn` of `tokenIn`.
+*
+* @param params - Swap parameters
+* @returns TxResult
+*
+* @example
+* ```typescript
+* const result = await swapExactIn({
+*   client, walletClient, account, poolAddress,
+*   chainId: 11155111n,
+*   tokenIn: USDC_ADDRESS,
+*   amountIn: 1000n * 10n**6n,  // 1000 USDC
+*   slippageBps: 500n,
+* })
+* const receipt = await result.wait()
+* ```
+*/
+async function swapExactIn(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountIn, slippageBps, existingPositionIds: explicitIds, storage, builderCode = 0n, txOverrides } = params;
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+		const [pool, positionIds] = await Promise.all([getPool({
+			client,
+			poolAddress,
+			chainId
+		}), resolvePositionIds(explicitIds, storage, chainId, poolAddress, account)]);
+		const token0 = pool.collateralTracker0.token;
+		const token1 = pool.collateralTracker1.token;
+		const tokenInIndex = resolveTokenIndex(tokenIn, token0, token1);
+		const call = buildCreditSwapCall({
+			kind: "exactIn",
+			poolAddress,
+			poolId: pool.poolId,
+			currentTick: pool.currentTick,
+			tickSpacing: pool.tickSpacing,
+			existingPositionIds: positionIds,
+			tokenIndex: tokenInIndex,
+			amountIn,
+			slippageBps,
+			builderCode
+		});
+		try {
+			return await submitWrite({
+				client,
+				walletClient,
+				account,
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "dispatch",
+				args: call.args,
+				txOverrides
+			});
+		} catch (error) {
+			if (isInputListFailError(error) && attempt < MAX_RETRIES - 1) continue;
+			throw error;
+		}
+	}
+	throw new MaxRetriesExceededError("swapExactIn");
+}
+/**
+* Swap exact input and wait for confirmation.
+*/
+async function swapExactInAndWait(params) {
+	const result = await swapExactIn(params);
+	return result.wait();
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/wrap.ts
+/** Minimal ERC4626 surface used by the xStock wrappers. */
+const xstockWrapperAbi = [
+	{
+		type: "function",
+		name: "deposit",
+		stateMutability: "nonpayable",
+		inputs: [{
+			name: "assets",
+			type: "uint256"
+		}, {
+			name: "receiver",
+			type: "address"
+		}],
+		outputs: [{
+			name: "shares",
+			type: "uint256"
+		}]
+	},
+	{
+		type: "function",
+		name: "redeem",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "shares",
+				type: "uint256"
+			},
+			{
+				name: "receiver",
+				type: "address"
+			},
+			{
+				name: "owner",
+				type: "address"
+			}
+		],
+		outputs: [{
+			name: "assets",
+			type: "uint256"
+		}]
+	},
+	{
+		type: "function",
+		name: "asset",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{ type: "address" }]
+	},
+	{
+		type: "function",
+		name: "previewDeposit",
+		stateMutability: "view",
+		inputs: [{
+			name: "assets",
+			type: "uint256"
+		}],
+		outputs: [{
+			name: "shares",
+			type: "uint256"
+		}]
+	},
+	{
+		type: "function",
+		name: "previewRedeem",
+		stateMutability: "view",
+		inputs: [{
+			name: "shares",
+			type: "uint256"
+		}],
+		outputs: [{
+			name: "assets",
+			type: "uint256"
+		}]
+	},
+	{
+		type: "function",
+		name: "maxRedeem",
+		stateMutability: "view",
+		inputs: [{
+			name: "owner",
+			type: "address"
+		}],
+		outputs: [{
+			name: "maxShares",
+			type: "uint256"
+		}]
+	}
+];
+/**
+* Wrap an underlying xStock into its ERC4626 wrapper (`deposit`). Requires a
+* prior ERC20 approval of the underlying to the wrapper address.
+*
+* @returns TxResult with hash and wait function
+*/
+async function wrapXstock(params) {
+	const { client, walletClient, account, wrapper, assets, receiver = account, txOverrides } = params;
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: wrapper,
+		abi: xstockWrapperAbi,
+		functionName: "deposit",
+		args: [assets, receiver],
+		txOverrides
+	});
+}
+/** Wrap and wait for confirmation. */
+async function wrapXstockAndWait(params) {
+	const result = await wrapXstock(params);
+	return result.wait();
+}
+/**
+* Unwrap wrapper shares back into the underlying xStock (`redeem`). When
+* `owner` defaults to (or equals) `account` the caller burns their own shares
+* and no approval is needed. Passing a different `owner` redeems on its behalf
+* and requires that owner to have granted the caller an ERC-4626 share
+* allowance (`approve`), or the `redeem` call reverts.
+*
+* @returns TxResult with hash and wait function
+*/
+async function unwrapXstock(params) {
+	const { client, walletClient, account, wrapper, shares, receiver = account, owner = account, txOverrides } = params;
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: wrapper,
+		abi: xstockWrapperAbi,
+		functionName: "redeem",
+		args: [
+			shares,
+			receiver,
+			owner
+		],
+		txOverrides
+	});
+}
+/** Unwrap and wait for confirmation. */
+async function unwrapXstockAndWait(params) {
+	const result = await unwrapXstock(params);
+	return result.wait();
+}
+/**
+* Preview the wrapper shares minted for a given amount of underlying xStock.
+*/
+async function previewWrap(params) {
+	const { client, wrapper, amount } = params;
+	return client.readContract({
+		address: wrapper,
+		abi: xstockWrapperAbi,
+		functionName: "previewDeposit",
+		args: [amount]
+	});
+}
+/**
+* Preview the underlying xStock returned for a given amount of wrapper shares.
+*/
+async function previewUnwrap(params) {
+	const { client, wrapper, amount } = params;
+	return client.readContract({
+		address: wrapper,
+		abi: xstockWrapperAbi,
+		functionName: "previewRedeem",
+		args: [amount]
+	});
+}
+/**
+* Minimal canonical WETH9 surface used for ETH<->WETH wrapping. Unlike the
+* ERC4626 xStock wrapper, WETH is a 1:1 wrapper: `deposit` is payable and wraps
+* `msg.value`, `withdraw` unwraps an exact amount back to native ETH.
+*/
+const wethWrapAbi = [{
+	type: "function",
+	name: "deposit",
+	stateMutability: "payable",
+	inputs: [],
+	outputs: []
+}, {
+	type: "function",
+	name: "withdraw",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "wad",
+		type: "uint256"
+	}],
+	outputs: []
+}];
+/**
+* Wrap native ETH into WETH (`deposit` payable). No approval needed.
+*
+* @returns TxResult with hash and wait function
+*/
+async function wrapEth(params) {
+	const { client, walletClient, account, weth, amount, txOverrides } = params;
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: weth,
+		abi: wethWrapAbi,
+		functionName: "deposit",
+		args: [],
+		value: amount,
+		txOverrides
+	});
+}
+/** Wrap ETH and wait for confirmation. */
+async function wrapEthAndWait(params) {
+	const result = await wrapEth(params);
+	return result.wait();
+}
+/**
+* Unwrap WETH back into native ETH (`withdraw`). Burns the caller's own WETH —
+* no approval needed.
+*
+* @returns TxResult with hash and wait function
+*/
+async function unwrapWeth(params) {
+	const { client, walletClient, account, weth, amount, txOverrides } = params;
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: weth,
+		abi: wethWrapAbi,
+		functionName: "withdraw",
+		args: [amount],
+		txOverrides
+	});
+}
+/** Unwrap WETH and wait for confirmation. */
+async function unwrapWethAndWait(params) {
+	const result = await unwrapWeth(params);
+	return result.wait();
+}
+
 //#endregion
 //#region src/panoptic/v2/simulations/simulateOpenPosition.ts
 /**
@@ -3829,4 +5740,4 @@ async function smartRepayAndWait(params) {
 }
 
 //#endregion
-export { addLegToTokenId, approve, approveAndWait, approvePool, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildOpenPositionCalldata, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateResyncBlock, cancelTransaction, checkApproval, clearCheckpoint, closePosition, closePositionAndWait, countLegs, createNonceManager, createTokenIdBuilder, decodeAllLegs, decodeLeg, decodePoolId, decodeTickSpacing as decodeTickSpacing$1, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodeV4PoolId, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, forceExercise, forceExerciseAndWait, getAssetIndex, getCurrentPositionSizes, getPoolDeploymentBlock, getPoolTokensForSimulation, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isInputListFailError, isLoan, isLoanLeg, isShortOnly, isSpread, liquidate, liquidateAndWait, loadCheckpoint, mint, mintAndWait, openPosition, openPositionAndWait, orderListForSettle, pokeOracle, pokeOracleAndWait, previewBorrow, previewUnwrap, previewWrap, publicBroadcaster, reconstructFromEvents, redeem, redeemAndWait, repay, repayAndWait, resolveTokenIndex, rollPosition, rollPositionAndWait, saveCheckpoint, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateOpenPosition, simulateWithTokenFlow, smartRepay, smartRepayAndWait, speedUpTransaction, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, validateBatch, validatePoolId, verifyBlockContinuity, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { addLegToTokenId, approve, approveAndWait, approvePool, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateResyncBlock, cancelTransaction, checkApproval, clearCheckpoint, closePosition, closePositionAndWait, countLegs, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllLegs, decodeLeg, decodePoolId, decodeTickSpacing$1, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveUniqueTokenId, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodeV4PoolId, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, generateOverlappingTokenIds, getAccountPremia, getAssetIndex, getForfeitablePremium, getPoolDeploymentBlock, getPoolDisplayId, getPoolTokensForSimulation, getPositionsWithPremia, getTokenListId, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isInputListFailError, isLoan, isLoanLeg, isShortOnly, isSpread, liquidate, liquidateAndWait, loadCheckpoint, mint, mintAndWait, openPosition, openPositionAndWait, orderListForSettle, parseBps, parseTokenListId, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewUnwrap, previewWrap, publicBroadcaster, reconstructFromEvents, redeem, redeemAndWait, repay, repayAndWait, resolveTokenIndex, rollPosition, rollPositionAndWait, saveCheckpoint, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateOpenPosition, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateWithTokenFlow, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, validateBatch, validatePoolId, verifyBlockContinuity, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };