@panoptic-eng/sdk 1.0.22 → 1.0.24

package/dist/panoptic/v2/index.js

@@ -1,8 +1,8 @@
-import { BORROW_INDEX_BITS, BPS_SCALE, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, UNREALIZED_INTEREST_BITS, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountCollateral, getAccountSummaryBasic, getAccountSummaryRisk, getChainDeployment, getCollateralAddresses, getCollateralData, getCurrentRates, getInterestState, getIrmCurrent, getIrmCurve, getLiquidationPrices, getNetLiquidationValue, getNetLiquidationValues, isLiquidatable, isSupportedChain, packMarketState, panopticQueryAbi, parseTokenAmount, parseWad, ratePerSecWadToAprPct, readBlockAndAggregate, requireChainDeployment, requireReturnData, utilizationBpsToWad, utilizationPctToWad } from "../../irm-DNK3N7qk.js";
-import { AccountInsolventError, AlreadyInitializedError, BPS_DENOMINATOR, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError$1 as PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, REORG_DEPTH, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, WAD$1 as WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing, fetchPoolId$1 as fetchPoolId, formatPriceRange$1 as formatPriceRange, formatTick$1 as formatTick, formatTickRange$1 as formatTickRange, getBlockMeta, getLegDelta, getLegGamma, getLegNetValueWidth0, getLegValue, getOracleState$1 as getOracleState, getPool$1 as getPool, getPoolMetadata$1 as getPoolMetadata, getPosition, getPositionGreeks, getPositions, getPricesAtTick$1 as getPricesAtTick, getRiskParameters$1 as getRiskParameters, getTickSpacing$1 as getTickSpacing, getUtilization$1 as getUtilization, isCall, isDefinedRisk, isPanopticErrorType, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi$1, parsePanopticError, priceToTick$1 as priceToTick, riskEngineAbi, roundToTickSpacing$1 as roundToTickSpacing, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, sqrtPriceX96ToPriceDecimalScaled$1 as sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick$1 as sqrtPriceX96ToTick, stateViewAbi, tickLimits$1 as tickLimits, tickToPrice$1 as tickToPrice, tickToPriceDecimalScaled$1 as tickToPriceDecimalScaled, tickToSqrtPriceX96$1 as tickToSqrtPriceX96, uniswapV3PoolAbi, validateBuilderCode$1 as validateBuilderCode } from "../../position-BK4a-Yyu.js";
-import { approveErc20ForCow, cancelCowOrder, checkCowApproval, getCowOrderStatus, isCowSupportedChain, quoteCowSwap, signAndSubmitCowOrder } from "../../cow-C_SGXoWr.js";
-import { addLegToTokenId, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateResyncBlock, cancelTransaction, checkApproval, clearCheckpoint, clearTrackedPositions, closePosition, closePositionAndWait, countLegs, createFileStorage, createMemoryStorage, createNonceManager, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeg, decodePoolId, decodeTickSpacing$1, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodeV4PoolId, executeBatchDispatch, executeBatchDispatchAndWait, forceExercise, forceExerciseAndWait, getAssetIndex, getClosedPositionsKey, getOpenPositionIds, getPendingPositionsKey, getPoolMetaKey, getPoolPrefix, getPositionMetaKey, getPositionsKey, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isGasError, isInputListFailError, isLoan, isLoanLeg, isNonceError, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, mint, mintAndWait, openPosition, openPositionAndWait, pokeOracle, pokeOracleAndWait, previewBorrow, previewUnwrap, previewWrap, publicBroadcaster, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, repay, repayAndWait, resolveTokenIndex, rollPosition, rollPositionAndWait, saveCheckpoint, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, 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 } from "../../writes-DymnVbiE.js";
-import { approveErc20ForPermit2, approveRouterViaPermit2, checkRouterApproval, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, swapExactInViaRouter, swapExactOutViaRouter } from "../../router-BZvOeloX.js";
+import { BORROW_INDEX_BITS, BPS_SCALE, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, UNREALIZED_INTEREST_BITS, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountCollateral, getAccountSummaryBasic, getAccountSummaryRisk, getChainDeployment, getCollateralAddresses, getCollateralData, getCurrentRates, getInterestState, getIrmCurrent, getIrmCurve, getLiquidationPrices, getNetLiquidationValue, getNetLiquidationValues, isLiquidatable, isSupportedChain, packMarketState, panopticQueryAbi$1 as panopticQueryAbi, parseTokenAmount, parseWad, ratePerSecWadToAprPct, readBlockAndAggregate, requireChainDeployment, requireReturnData, utilizationBpsToWad, utilizationPctToWad } from "../../irm-Dw6fa-DV.js";
+import { AccountInsolventError, AlreadyInitializedError, BPS_DENOMINATOR, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, REORG_DEPTH, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing, fetchPoolId, formatPriceRange, formatTick, formatTickRange, getBlockMeta, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getOracleState, getPool, getPoolMetadata, getPosition, getPositionGreeks, getPositions, getPricesAtTick, getRiskParameters, getTickSpacing, getUtilization, isCall, isDefinedRisk, isPanopticErrorType, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, priceToTick, riskEngineAbi, roundToTickSpacing, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, stateViewAbi, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, uniswapV3PoolAbi, validateBuilderCode } from "../../position-GYsTTl71.js";
+import { approveErc20ForCow, cancelCowOrder, checkCowApproval, getCowOrderStatus, isCowSupportedChain, quoteCowSwap, signAndSubmitCowOrder } from "../../cow-DW6LjXES.js";
+import { addLegToTokenId, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateResyncBlock, cancelTransaction, checkApproval, clearCheckpoint, clearTrackedPositions, closePosition, closePositionAndWait, countLegs, createFileStorage, createMemoryStorage, createNonceManager, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeg, decodePoolId, decodeTickSpacing$1, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodeV4PoolId, executeBatchDispatch, executeBatchDispatchAndWait, forceExercise, forceExerciseAndWait, getAssetIndex, getClosedPositionsKey, getOpenPositionIds, getPendingPositionsKey, getPoolMetaKey, getPoolPrefix, getPositionMetaKey, getPositionsKey, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isGasError, isInputListFailError, isLoan, isLoanLeg, isNonceError, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, mint, mintAndWait, openPosition, openPositionAndWait, pokeOracle, pokeOracleAndWait, previewBorrow, previewUnwrap, previewWrap, publicBroadcaster, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, repay, repayAndWait, resolveTokenIndex, rollPosition, rollPositionAndWait, saveCheckpoint, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, 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 } from "../../writes-h-IX3XQq.js";
+import { approveErc20ForPermit2, approveRouterViaPermit2, checkRouterApproval, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, swapExactInViaRouter, swapExactOutViaRouter } from "../../router-_vB5ArjF.js";
 import { ContractFunctionExecutionError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 import { createContext, useContext, useEffect, useRef, useState } from "react";
@@ -971,6 +971,15 @@ async function getPositionsWithPremia(params) {
 //#endregion
 //#region src/panoptic/v2/reads/collateralEstimate.ts
 /**
+* Max int24 (2^23 - 1), used as the per-position `effectiveLiquidityLimit` (the
+* 3rd element of the dispatch tickAndSpreadLimits triplet). Passing this lets the
+* contract clamp to its real on-chain `maxSpread()` ceiling, matching the live
+* trade. Passing 0 instead forces the limit to 0, so any long-leg removal reverts
+* with EffectiveLiquidityAboveThreshold and ITM/size measurements silently
+* collapse (see PanopticPool._mintInSFPMAndUpdateCollateral / _checkLiquiditySpread).
+*/
+const MAX_EFFECTIVE_LIQUIDITY_LIMIT = 8388607;
+/**
 * Maximum value of a Solidity `uint64`. `PanopticQuery.getRequiredBase` computes
 * the requirement for a synthetic position sized at `type(uint64).max`, so the
 * returned value must be scaled down to the caller's actual `positionSize`.
@@ -1038,7 +1047,7 @@ async function estimateCollateralRequired(params) {
 * @returns Maximum position size with bounds and block metadata
 */
 async function getMaxPositionSize(params) {
-	const { client, poolAddress, account, tokenId, queryAddress, existingPositionIds, storage, chainId, refine = true, precisionPct = 1, swapAtMint = false, blockNumber } = params;
+	const { client, poolAddress, account, tokenId, queryAddress, existingPositionIds, storage, chainId, refine = true, precisionPct = 1, swapAtMint = false, usePremiaAsCollateral = false, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
 	let positionIds;
 	if (existingPositionIds !== void 0) positionIds = existingPositionIds;
@@ -1081,7 +1090,8 @@ async function getMaxPositionSize(params) {
 		low: maxSizeAtMaxUtil / 2n,
 		high: maxSizeAtMinUtil * 2n,
 		precisionDivisor,
-		swapAtMint
+		swapAtMint,
+		usePremiaAsCollateral
 	});
 	return {
 		maxSize,
@@ -1095,7 +1105,7 @@ async function getMaxPositionSize(params) {
 * Tests 5 points per round (sextiles), narrowing the range by 6x each iteration.
 */
 async function binarySearchMaxSize(params) {
-	const { client, poolAddress, account, tokenId, existingPositionIds, precisionDivisor, swapAtMint } = params;
+	const { client, poolAddress, account, tokenId, existingPositionIds, precisionDivisor, swapAtMint, usePremiaAsCollateral } = params;
 	let { low, high } = params;
 	const trySize = (positionSize) => tryDispatchSimulation({
 		client,
@@ -1104,7 +1114,8 @@ async function binarySearchMaxSize(params) {
 		tokenId,
 		existingPositionIds,
 		positionSize,
-		swapAtMint
+		swapAtMint,
+		usePremiaAsCollateral
 	});
 	while (high - low > 1n && high - low > low / precisionDivisor) {
 		const range = high - low;
@@ -1141,10 +1152,9 @@ async function binarySearchMaxSize(params) {
 * Try to simulate opening a position with the given size.
 */
 async function tryDispatchSimulation(params) {
-	const { client, poolAddress, account, tokenId, existingPositionIds, positionSize, swapAtMint } = params;
+	const { client, poolAddress, account, tokenId, existingPositionIds, positionSize, swapAtMint, usePremiaAsCollateral } = params;
 	try {
 		const finalPositionIdList = [...existingPositionIds, tokenId];
-		const MAX_EFFECTIVE_LIQUIDITY_LIMIT = 8388607;
 		const tickLimits$1 = swapAtMint ? [
 			887272,
 			-887272,
@@ -1162,7 +1172,7 @@ async function tryDispatchSimulation(params) {
 				finalPositionIdList,
 				[positionSize],
 				[tickLimits$1],
-				true,
+				usePremiaAsCollateral,
 				0n
 			]
 		});
@@ -1207,9 +1217,19 @@ async function tryDispatchSimulation(params) {
 * ```
 */
 async function getRequiredCreditForITM(params) {
-	const { client, poolAddress, account, tokenId, positionSize, existingPositionIds = [], blockNumber } = params;
+	const { client, poolAddress, account, tokenId, positionSize, existingPositionIds = [], swapAtMint = true, blockNumber } = params;
+	if (blockNumber !== void 0 && params._meta !== void 0 && params._meta.blockNumber !== blockNumber) throw new PanopticError("getRequiredCreditForITM: blockNumber and _meta.blockNumber disagree; cannot guarantee same-block consistency");
 	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
 	const finalPositionIdList = [...existingPositionIds, tokenId];
+	const tickTriplet = swapAtMint ? [
+		Number(MAX_TICK),
+		Number(MIN_TICK),
+		MAX_EFFECTIVE_LIQUIDITY_LIMIT
+	] : [
+		Number(MIN_TICK),
+		Number(MAX_TICK),
+		MAX_EFFECTIVE_LIQUIDITY_LIMIT
+	];
 	const callData = encodeFunctionData({
 		abi: panopticPoolV2Abi,
 		functionName: "dispatch",
@@ -1217,11 +1237,7 @@ async function getRequiredCreditForITM(params) {
 			[tokenId],
 			finalPositionIdList,
 			[positionSize],
-			[[
-				Number(MAX_TICK),
-				Number(MIN_TICK),
-				0
-			]],
+			[tickTriplet],
 			false,
 			0n
 		]
@@ -1245,6 +1261,298 @@ async function getRequiredCreditForITM(params) {
 	};
 }
 /**
+* Read the net `itmAmounts` a mint of `tokenId` would produce, via
+* `PanopticQuery.getItmAmounts`. This is the swap-independent, per-leg-linear
+* projection that drives the SFPM's mint-time netting swap: the swap only fires
+* when `itmAmounts != 0`. Sizing width=0 legs so the combined tokenId returns
+* (~0, ~0) here makes the mint swap dust — regardless of Zap vs cover.
+*
+* @param params - The parameters
+* @returns The net itm0/itm1 with block metadata
+*/
+async function getItmAmounts(params) {
+	const { client, queryAddress, poolAddress, tokenId, positionSize, blockNumber } = params;
+	if (blockNumber !== void 0 && params._meta !== void 0 && params._meta.blockNumber !== blockNumber) throw new PanopticError("getItmAmounts: blockNumber and _meta.blockNumber disagree; cannot guarantee same-block consistency");
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const [result, _meta] = await Promise.all([client.readContract({
+		address: queryAddress,
+		abi: panopticQueryAbi,
+		functionName: "getItmAmounts",
+		args: [
+			poolAddress,
+			tokenId,
+			positionSize
+		],
+		blockNumber: targetBlockNumber
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [itm0, itm1] = result;
+	return {
+		itm0,
+		itm1,
+		_meta
+	};
+}
+/**
+* Dust threshold (token1 value units) below which an itm amount is treated as
+* zero — negligible token flow not worth a neutralizing leg. token0 amounts are
+* converted to token1 value at the current tick before comparison so a tiny
+* high-decimal amount can't masquerade as real flow.
+*/
+const FLOW_NEUTRAL_DUST_THRESHOLD = 1000n;
+const Q192$1 = 1n << 192n;
+const POOL_ID_MASK = (1n << 64n) - 1n;
+/**
+* Floor integer square root for bigints (Newton's method). Exact for all
+* non-negative inputs — no float precision loss for values above 2^53.
+*/
+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;
+}
+/**
+* Solve a single width=0 neutralizing leg sized to offset a token's signed itm.
+*
+* The leg moves `tokenIndex`'s token (`tokenType = tokenIndex`) and is denominated
+* in the opposite asset (`asset = 1 - tokenIndex`) so `asset ≠ tokenType` and the
+* notional scales continuously by strike: `notional ≈ positionSize · 1.0001^signed`.
+* `signedAmount` is the itm to cancel (the leg's itm contribution is `-signedAmount`):
+* positive itm ⇒ a short LOAN leg (isLong=0), negative itm ⇒ a long CREDIT leg (isLong=1).
+*
+* Width=0 legs never mint Uniswap liquidity (see SFPM `_createPositionInAMM`), so their
+* strike is NOT grid-constrained — we use full 1-tick granularity for the tightest sizing.
+* The closed form `positionSize·1.0001^strike` matches the contract's width-2-chunk
+* `getAmountsMoved` to within ~dust, so no correction loop is needed.
+* Throws `PanopticError` if the required strike leaves the valid (exclusive) tick range.
+*/
+function buildNeutralLeg(tokenIndex, signedAmount, positionSize) {
+	const absAmount = signedAmount < 0n ? -signedAmount : signedAmount;
+	const legAsset = tokenIndex === 0n ? 1n : 0n;
+	const legIsLong = signedAmount < 0n;
+	const sqrtKrawX96 = isqrt(absAmount * Q192$1 / positionSize);
+	let signedTick;
+	try {
+		signedTick = sqrtPriceX96ToTick(sqrtKrawX96);
+	} catch {
+		throw new PanopticError("Cannot create flow-neutral position: neutralizing strike out of bounds");
+	}
+	if (signedTick <= MIN_TICK || signedTick >= MAX_TICK) throw new PanopticError("Cannot create flow-neutral position: neutralizing strike out of bounds");
+	const strike = legAsset === 0n ? signedTick : -signedTick;
+	return {
+		strike,
+		asset: legAsset,
+		tokenType: tokenIndex,
+		isCredit: legIsLong
+	};
+}
+/**
+* Assemble a tokenId with the neutralizing legs (self-partnered, width=0) placed either
+* BEFORE or AFTER the base legs.
+*
+* The leg at index 0 sets the position's swap frame (the token the Zap sources) and the
+* canonical `positionSize` denomination, so placement is asset-directed:
+*   - `prepend=false` (default, e.g. PUTs): base legs keep their indices (option leg stays
+*     at index 0); neutral legs are appended at `baseLegCount..`.
+*   - `prepend=true` (e.g. CALLs): neutral legs occupy indices `0..k-1` and the base legs
+*     shift by `k` (riskPartner remapped: self-partners follow their new index, cross
+*     partners +k). This puts the credit leg first so the mint swap is asset-token
+*     friendly for a call.
+*/
+function assembleNeutralTokenId(poolId, baseTokenId, neutralLegs, prepend) {
+	let out = poolId;
+	const baseLegs = decodeAllLegs(baseTokenId);
+	const k = BigInt(neutralLegs.length);
+	const shift = prepend ? k : 0n;
+	if (prepend) neutralLegs.forEach((leg, i) => {
+		const index = BigInt(i);
+		out = addLegToTokenId(out, {
+			index,
+			asset: leg.asset,
+			tokenType: leg.tokenType,
+			optionRatio: 1n,
+			isLong: leg.isCredit ? 1n : 0n,
+			riskPartner: index,
+			strike: leg.strike,
+			width: 0n
+		});
+	});
+	for (const leg of baseLegs) {
+		const newIndex = leg.index + shift;
+		const newRiskPartner = leg.riskPartner === leg.index ? newIndex : leg.riskPartner + shift;
+		out = addLegToTokenId(out, {
+			index: newIndex,
+			asset: leg.asset,
+			tokenType: leg.tokenType,
+			optionRatio: leg.optionRatio,
+			isLong: leg.isLong ? 1n : 0n,
+			riskPartner: newRiskPartner,
+			strike: leg.strike,
+			width: leg.width
+		});
+	}
+	if (!prepend) {
+		const base = BigInt(baseLegs.length);
+		neutralLegs.forEach((leg, i) => {
+			const index = base + BigInt(i);
+			out = addLegToTokenId(out, {
+				index,
+				asset: leg.asset,
+				tokenType: leg.tokenType,
+				optionRatio: 1n,
+				isLong: leg.isCredit ? 1n : 0n,
+				riskPartner: index,
+				strike: leg.strike,
+				width: 0n
+			});
+		});
+	}
+	return out;
+}
+/**
+* Create a flow-neutral tokenId by adding width=0 credit/loan leg(s) that zero the
+* position's NET token transfer at mint — the amount the user would otherwise send/receive
+* (and be surprised by at burn).
+*
+* Each leg is sized against the **realized net flow**, measured by
+* {@link getRequiredCreditForITM} under the mint's own `swapAtMint`. Verified on-chain: a
+* width=0 leg's marginal effect on its token's flow is LINEAR and 1:1 with its notional
+* (`positionSize · 1.0001^strike`, matching the contract's `getAmountsMoved`). So sizing the
+* notional to `|net flow|` and solving the strike directly drives the residual to ~dust in
+* ONE shot — no fixed-point loop. (Example: flow 122.08 USDC → strike −228275 → residual
+* −0.032 USDC.)
+*
+* How many legs, keyed on swap mode:
+*  - **Zap** (`swapAtMint=true`): the mint swap consolidates the flow into ONE token and a
+*    width=0 leg can only move the asset axis afterwards, so we add a single leg on the
+*    dominant token; the smaller side is a swap artifact left as dust.
+*  - **Cover** (`swapAtMint=false`): no swap, so the flow is genuinely two-sided and each
+*    token's flow is independent — we add one leg PER token above dust (up to 2), each
+*    sized 1:1 to its own side. This neutralizes both sides of e.g. a two-leg straddle.
+* Each width=0 leg has `asset ≠ tokenType` (strike-tunable):
+*   - token0 flow ← width=0 call leg (tokenType0, asset1)
+*   - token1 flow ← width=0 put  leg (tokenType1, asset0)
+* `creditAmount = −delta`: a positive amount (user would deposit) → a short LOAN leg;
+* negative (user would receive) → a long CREDIT leg. `neutralizedTokenFlow` is a single
+* verify measurement of the combined position under the ACTUAL mint swap mode.
+*
+* Neutral legs (self-partnered, width=0) are placed so index 0 carries the correct swap
+* frame: for a single-leg CALL (option `tokenType === asset`) they are PREPENDED so the
+* credit leg leads and the mint swap is asset-token friendly; for a PUT (and any multi-leg
+* base) they are APPENDED so the option leg stays at index 0. `positionSize` is never
+* modified.
+*
+* @param params - The parameters
+* @returns The flow-neutral tokenId, the neutralizing legs, the base net-flow
+*   measurement, and the combined position's residual flow. `neutralLegs` is empty
+*   when the position is OTM (input tokenId returned unchanged).
+* @throws PanopticError if positionSize <= 0, base legs + 1 > 4, the current tick
+*   is unavailable, or a neutralizing strike falls outside the valid tick range.
+*/
+async function createFlowNeutralTokenId(params) {
+	const { client, poolAddress, account, tokenId, positionSize, existingPositionIds, swapAtMint = true, referenceSize, queryAddress, blockNumber } = params;
+	if (positionSize <= 0n) throw new PanopticError("positionSize must be positive to create flow-neutral position");
+	const measureSize = referenceSize !== void 0 && referenceSize > 0n && referenceSize < positionSize ? referenceSize : positionSize;
+	const legCount = countLegs(tokenId);
+	if (legCount >= 4n) throw new PanopticError("Cannot append neutralizing leg: tokenId already has 4 legs");
+	const poolId = tokenId & POOL_ID_MASK;
+	const baseLegs = decodeAllLegs(tokenId);
+	const prependNeutral = baseLegs.length === 1 && baseLegs[0].tokenType === baseLegs[0].asset;
+	const credit = await getRequiredCreditForITM({
+		client,
+		poolAddress,
+		account,
+		tokenId,
+		positionSize: measureSize,
+		existingPositionIds,
+		swapAtMint,
+		blockNumber,
+		_meta: params._meta
+	});
+	const tickBefore = credit.tokenFlow.tickBefore;
+	if (tickBefore === null) throw new PanopticError("Cannot create flow-neutral position: current tick unavailable");
+	const sqrtPX96 = tickToSqrtPriceX96(tickBefore);
+	const valueAbs = (index, amount) => {
+		const abs = amount < 0n ? -amount : amount;
+		return index === 0n ? abs * sqrtPX96 * sqrtPX96 / Q192$1 : abs;
+	};
+	const flowFor = (index) => index === 0n ? credit.creditAmount0 : credit.creditAmount1;
+	if (queryAddress !== void 0) {
+		const itm = await getItmAmounts({
+			client,
+			queryAddress,
+			poolAddress,
+			tokenId,
+			positionSize: measureSize,
+			blockNumber: blockNumber ?? credit._meta.blockNumber,
+			_meta: credit._meta
+		});
+		if (valueAbs(0n, itm.itm0) <= FLOW_NEUTRAL_DUST_THRESHOLD && valueAbs(1n, itm.itm1) <= FLOW_NEUTRAL_DUST_THRESHOLD) return {
+			tokenId,
+			positionSize,
+			neutralLegs: [],
+			originalCredit: credit,
+			neutralizedTokenFlow: credit.tokenFlow,
+			_meta: credit._meta
+		};
+	}
+	if (valueAbs(0n, credit.creditAmount0) <= FLOW_NEUTRAL_DUST_THRESHOLD && valueAbs(1n, credit.creditAmount1) <= FLOW_NEUTRAL_DUST_THRESHOLD) return {
+		tokenId,
+		positionSize,
+		neutralLegs: [],
+		originalCredit: credit,
+		neutralizedTokenFlow: credit.tokenFlow,
+		_meta: credit._meta
+	};
+	const indices = swapAtMint ? [valueAbs(0n, credit.creditAmount0) >= valueAbs(1n, credit.creditAmount1) ? 0n : 1n] : [0n, 1n].filter((i) => valueAbs(i, flowFor(i)) > FLOW_NEUTRAL_DUST_THRESHOLD);
+	if (legCount + BigInt(indices.length) > 4n) throw new PanopticError(`Cannot add ${indices.length} neutralizing leg(s): tokenId would exceed 4 legs`);
+	const neutralLegs = indices.map((i) => buildNeutralLeg(i, flowFor(i), measureSize));
+	const combined = assembleNeutralTokenId(poolId, tokenId, neutralLegs, prependNeutral);
+	const pinnedBlock = blockNumber ?? credit._meta.blockNumber;
+	let residual;
+	try {
+		residual = await getRequiredCreditForITM({
+			client,
+			poolAddress,
+			account,
+			tokenId: combined,
+			positionSize,
+			existingPositionIds,
+			swapAtMint,
+			blockNumber: pinnedBlock,
+			_meta: credit._meta
+		});
+	} catch {
+		residual = await getRequiredCreditForITM({
+			client,
+			poolAddress,
+			account,
+			tokenId: combined,
+			positionSize: measureSize,
+			existingPositionIds,
+			swapAtMint,
+			blockNumber: pinnedBlock,
+			_meta: credit._meta
+		});
+	}
+	return {
+		tokenId: combined,
+		positionSize,
+		neutralLegs,
+		originalCredit: credit,
+		neutralizedTokenFlow: residual.tokenFlow,
+		_meta: credit._meta
+	};
+}
+/**
 * Find the maximum withdrawable amount from a CollateralTracker using binary search.
 *
 * When a user has open positions, the standard `maxWithdraw()` returns 0 because
@@ -5273,6 +5581,13 @@ const queryKeys = {
 		account,
 		tokenId.toString()
 	],
+	flowNeutralTokenId: (chainId, poolAddress, tokenId) => [
+		...queryKeys.all,
+		"flowNeutralTokenId",
+		chainId.toString(),
+		poolAddress,
+		tokenId.toString()
+	],
 	interestState: (chainId, poolAddress, account) => [
 		...queryKeys.all,
 		"interestState",
@@ -5917,6 +6232,46 @@ function useEstimateCollateralRequired(poolAddress, tokenId, positionSize, query
 		gcTime: options?.gcTime
 	});
 }
+function useFlowNeutralTokenId(poolAddress, tokenId, positionSize, account, options) {
+	const ctx = usePanopticContext();
+	const resolvedAccount = account ?? ctx.account;
+	const neutralizeITM = options?.neutralizeITM ?? true;
+	const swapAtMint = options?.swapAtMint ?? true;
+	const referenceSize = options?.referenceSize;
+	const queryAddress = options?.queryAddress;
+	return useQuery({
+		queryKey: [
+			...queryKeys.flowNeutralTokenId(ctx.chainId, poolAddress, tokenId),
+			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			resolvedAccount ?? "",
+			positionSize.toString(),
+			(options?.existingPositionIds ?? []).map(String).join(","),
+			neutralizeITM,
+			swapAtMint,
+			positionSize,
+			options?.existingPositionIds,
+			(referenceSize ?? 0n).toString(),
+			referenceSize,
+			queryAddress ?? ""
+		],
+		queryFn: () => {
+			if (!resolvedAccount) throw new Error("account required for createFlowNeutralTokenId");
+			return createFlowNeutralTokenId({
+				client: ctx.publicClient,
+				poolAddress,
+				account: resolvedAccount,
+				tokenId,
+				positionSize,
+				existingPositionIds: options?.existingPositionIds,
+				swapAtMint,
+				referenceSize,
+				queryAddress
+			});
+		},
+		enabled: (options?.enabled ?? true) && neutralizeITM && !!resolvedAccount && tokenId !== 0n && positionSize > 0n,
+		refetchInterval: options?.refetchInterval
+	});
+}
 function useMaxPositionSize(poolAddress, tokenId, queryAddress, account, options) {
 	const ctx = usePanopticContext();
 	const resolvedAccount = account ?? ctx.account;
@@ -5928,7 +6283,8 @@ function useMaxPositionSize(poolAddress, tokenId, queryAddress, account, options
 			options?.existingPositionIds?.map(String).join(",") ?? "",
 			options?.existingPositionIds,
 			options?.swapAtMint ?? false,
-			options?.precisionPct ?? 1
+			options?.precisionPct ?? 1,
+			options?.usePremiaAsCollateral ?? false
 		],
 		queryFn: () => {
 			if (!resolvedAccount) throw new Error("account required for getMaxPositionSize");
@@ -5940,7 +6296,8 @@ function useMaxPositionSize(poolAddress, tokenId, queryAddress, account, options
 				queryAddress,
 				existingPositionIds: options?.existingPositionIds,
 				swapAtMint: options?.swapAtMint,
-				precisionPct: options?.precisionPct
+				precisionPct: options?.precisionPct,
+				usePremiaAsCollateral: options?.usePremiaAsCollateral
 			});
 		},
 		enabled: (options?.enabled ?? true) && !!resolvedAccount,
@@ -10921,5 +11278,5 @@ function useTxEventConfirmation({ txHash, poolAddress = zeroAddress, collateralT
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodePanopticTokenURI, decodePoolId, decodeTickSpacing$1 as decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, estimateBlockNumbers, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, fetchPoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getInterestState, getIrmCurrent, getIrmCurve, getLegDelta, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getOpenPositionIds, getOpenPositionPreview, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, smartRepay, smartRepayAndWait, speedUpTransaction, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useForceExercise as useForceExerciseHook, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticProvider, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildOpenPositionCalldata, buildUniqueLoan, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodePanopticTokenURI, decodePoolId, decodeTickSpacing$1 as decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, detectReorg, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, estimateBlockNumbers, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, fetchPoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getOpenPositionIds, getOpenPositionPreview, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, smartRepay, smartRepayAndWait, speedUpTransaction, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=index.js.map