@panoptic-eng/sdk 1.0.23 → 1.0.25

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$1 as panopticQueryAbi, parseTokenAmount, parseWad, ratePerSecWadToAprPct, readBlockAndAggregate, requireChainDeployment, requireReturnData, utilizationBpsToWad, utilizationPctToWad } from "../../irm-C7EQwrga.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, 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, uniswapV3PoolAbi, validateBuilderCode } from "../../position-CsIEneku.js";
-import { approveErc20ForCow, cancelCowOrder, checkCowApproval, getCowOrderStatus, isCowSupportedChain, quoteCowSwap, signAndSubmitCowOrder } from "../../cow-BilQfbNT.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-BnO9zj-Z.js";
-import { approveErc20ForPermit2, approveRouterViaPermit2, checkRouterApproval, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, swapExactInViaRouter, swapExactOutViaRouter } from "../../router-BM10ZWY5.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";
@@ -1047,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;
@@ -1090,7 +1090,8 @@ async function getMaxPositionSize(params) {
 		low: maxSizeAtMaxUtil / 2n,
 		high: maxSizeAtMinUtil * 2n,
 		precisionDivisor,
-		swapAtMint
+		swapAtMint,
+		usePremiaAsCollateral
 	});
 	return {
 		maxSize,
@@ -1104,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,
@@ -1113,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;
@@ -1150,7 +1152,7 @@ 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 tickLimits$1 = swapAtMint ? [
@@ -1170,7 +1172,7 @@ async function tryDispatchSimulation(params) {
 				finalPositionIdList,
 				[positionSize],
 				[tickLimits$1],
-				true,
+				usePremiaAsCollateral,
 				0n
 			]
 		});
@@ -1215,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",
@@ -1225,11 +1237,7 @@ async function getRequiredCreditForITM(params) {
 			[tokenId],
 			finalPositionIdList,
 			[positionSize],
-			[[
-				Number(MAX_TICK),
-				Number(MIN_TICK),
-				MAX_EFFECTIVE_LIQUIDITY_LIMIT
-			]],
+			[tickTriplet],
 			false,
 			0n
 		]
@@ -1253,11 +1261,45 @@ async function getRequiredCreditForITM(params) {
 	};
 }
 /**
-* Dust threshold (raw token units) below which an ITM measurement is treated as
-* zero. Token-flow deltas carry sub-unit rounding noise from on-chain math and
-* the sqrt/tick conversions below; 1000n raw units swallows that noise while
-* staying many orders of magnitude below any real ITM credit (which is on the
-* order of `positionSize`).
+* 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;
@@ -1278,124 +1320,235 @@ function isqrt(value) {
 	return x;
 }
 /**
-* Round a signed tick to the nearest multiple of `spacing` (bigint, nearest).
+* 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 roundToSpacing(tick, spacing) {
-	if (spacing <= 1n) return tick;
-	const half = spacing / 2n;
-	const quotient = tick >= 0n ? (tick + half) / spacing : (tick - half) / spacing;
-	return quotient * spacing;
+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
+	};
 }
 /**
-* Create a flow-neutral tokenId by prepending a width=0 credit/loan leg that
-* offsets the net ITM token flow.
-*
-* When a position is ITM, opening it produces an imbalanced single-sided token
-* flow. This function measures that net flow via {@link getRequiredCreditForITM}
-* and prepends a single width=0 leg (at index 0, with `asset !== tokenType` so
-* its notional scales continuously by strike) sized so its token flow is equal
-* and opposite. The result has net flow ~zero at mint.
-*
-* The leg occupies index 0; existing legs are shifted to indices 1..n with their
-* `riskPartner` references remapped (self-partners stay self, cross-partners +1).
-* The input `positionSize` is never modified — the leg is sized via its strike.
+* 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 with metadata
-* @throws PanopticError if the tokenId already has 4 legs, positionSize <= 0, or
-*   the required neutralizing strike falls outside the valid tick range.
+* @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, blockNumber } = 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 prepend neutralizing leg: tokenId already has 4 legs");
+	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,
+		positionSize: measureSize,
 		existingPositionIds,
+		swapAtMint,
 		blockNumber,
 		_meta: params._meta
 	});
-	const abs0 = credit.creditAmount0 < 0n ? -credit.creditAmount0 : credit.creditAmount0;
-	const abs1 = credit.creditAmount1 < 0n ? -credit.creditAmount1 : credit.creditAmount1;
 	const tickBefore = credit.tokenFlow.tickBefore;
 	if (tickBefore === null) throw new PanopticError("Cannot create flow-neutral position: current tick unavailable");
 	const sqrtPX96 = tickToSqrtPriceX96(tickBefore);
-	const abs0InToken1 = abs0 * sqrtPX96 * sqrtPX96 / Q192$1;
-	let itmTokenIndex;
-	let amount;
-	if (abs0InToken1 <= FLOW_NEUTRAL_DUST_THRESHOLD && abs1 <= FLOW_NEUTRAL_DUST_THRESHOLD) return {
+	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,
-		neutralStrike: 0n,
-		neutralAsset: 0n,
-		neutralTokenType: 0n,
-		neutralIsCredit: false,
+		neutralLegs: [],
 		originalCredit: credit,
-		strikeResidualTick: 0n,
+		neutralizedTokenFlow: credit.tokenFlow,
 		_meta: credit._meta
 	};
-	else if (abs0InToken1 >= abs1) {
-		itmTokenIndex = 0n;
-		amount = credit.creditAmount0;
-	} else {
-		itmTokenIndex = 1n;
-		amount = credit.creditAmount1;
-	}
-	const absAmount = amount < 0n ? -amount : amount;
-	const legTokenType = itmTokenIndex;
-	const legAsset = itmTokenIndex === 0n ? 1n : 0n;
-	const legIsLong = amount < 0n;
-	const sqrtKrawX96 = isqrt(absAmount * Q192$1 / positionSize);
-	let signedTick;
+	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 {
-		signedTick = sqrtPriceX96ToTick(sqrtKrawX96);
+		residual = await getRequiredCreditForITM({
+			client,
+			poolAddress,
+			account,
+			tokenId: combined,
+			positionSize,
+			existingPositionIds,
+			swapAtMint,
+			blockNumber: pinnedBlock,
+			_meta: credit._meta
+		});
 	} catch {
-		throw new PanopticError("Cannot create flow-neutral position: neutralizing strike out of bounds");
-	}
-	const tickSpacing = decodeTickSpacing$1(tokenId);
-	const roundedTick = roundToSpacing(signedTick, tickSpacing);
-	const strikeResidualTick = signedTick - roundedTick;
-	if (roundedTick < MIN_TICK || roundedTick > MAX_TICK) throw new PanopticError("Cannot create flow-neutral position: neutralizing strike out of bounds");
-	const neutralStrike = legAsset === 0n ? roundedTick : -roundedTick;
-	const poolId = tokenId & POOL_ID_MASK;
-	let newTokenId = addLegToTokenId(poolId, {
-		index: 0n,
-		asset: legAsset,
-		tokenType: legTokenType,
-		optionRatio: 1n,
-		isLong: legIsLong ? 1n : 0n,
-		riskPartner: 0n,
-		strike: neutralStrike,
-		width: 0n
-	});
-	for (const leg of decodeAllLegs(tokenId)) {
-		const newIndex = leg.index + 1n;
-		const newRiskPartner = leg.riskPartner === leg.index ? newIndex : leg.riskPartner + 1n;
-		newTokenId = addLegToTokenId(newTokenId, {
-			index: newIndex,
-			asset: leg.asset,
-			tokenType: leg.tokenType,
-			optionRatio: leg.optionRatio,
-			isLong: leg.isLong ? 1n : 0n,
-			riskPartner: newRiskPartner,
-			strike: leg.strike,
-			width: leg.width
+		residual = await getRequiredCreditForITM({
+			client,
+			poolAddress,
+			account,
+			tokenId: combined,
+			positionSize: measureSize,
+			existingPositionIds,
+			swapAtMint,
+			blockNumber: pinnedBlock,
+			_meta: credit._meta
 		});
 	}
 	return {
-		tokenId: newTokenId,
+		tokenId: combined,
 		positionSize,
-		neutralStrike,
-		neutralAsset: legAsset,
-		neutralTokenType: legTokenType,
-		neutralIsCredit: legIsLong,
+		neutralLegs,
 		originalCredit: credit,
-		strikeResidualTick,
+		neutralizedTokenFlow: residual.tokenFlow,
 		_meta: credit._meta
 	};
 }
@@ -5428,12 +5581,11 @@ const queryKeys = {
 		account,
 		tokenId.toString()
 	],
-	flowNeutralTokenId: (chainId, poolAddress, account, tokenId) => [
+	flowNeutralTokenId: (chainId, poolAddress, tokenId) => [
 		...queryKeys.all,
 		"flowNeutralTokenId",
 		chainId.toString(),
 		poolAddress,
-		account,
 		tokenId.toString()
 	],
 	interestState: (chainId, poolAddress, account) => [
@@ -6084,15 +6236,23 @@ function useFlowNeutralTokenId(poolAddress, tokenId, positionSize, account, opti
 	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, resolvedAccount ?? "", tokenId),
+			...queryKeys.flowNeutralTokenId(ctx.chainId, poolAddress, tokenId),
 			getClientCacheScopeKey(ctx.publicClient, ctx.clientScope),
+			resolvedAccount ?? "",
 			positionSize.toString(),
 			(options?.existingPositionIds ?? []).map(String).join(","),
 			neutralizeITM,
+			swapAtMint,
 			positionSize,
-			options?.existingPositionIds
+			options?.existingPositionIds,
+			(referenceSize ?? 0n).toString(),
+			referenceSize,
+			queryAddress ?? ""
 		],
 		queryFn: () => {
 			if (!resolvedAccount) throw new Error("account required for createFlowNeutralTokenId");
@@ -6102,7 +6262,10 @@ function useFlowNeutralTokenId(poolAddress, tokenId, positionSize, account, opti
 				account: resolvedAccount,
 				tokenId,
 				positionSize,
-				existingPositionIds: options?.existingPositionIds
+				existingPositionIds: options?.existingPositionIds,
+				swapAtMint,
+				referenceSize,
+				queryAddress
 			});
 		},
 		enabled: (options?.enabled ?? true) && neutralizeITM && !!resolvedAccount && tokenId !== 0n && positionSize > 0n,
@@ -6120,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");
@@ -6132,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,
@@ -11113,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, 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, 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, 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 };
+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