@panoptic-eng/sdk 1.0.37 → 1.0.38

package/dist/{position-C8rkkKhi.js → getTrackedPositionIds-zYPIs5dt.js}

@@ -1,5 +1,5 @@
-import { calculatePositionGreeks, tickToSqrtPriceX96 } from "./greeks-GysWXct-.js";
-import { BaseError, decodeAbiParameters, decodeErrorResult, decodeEventLog, encodeFunctionData, keccak256, toFunctionSelector, zeroAddress } from "viem";
+import { ORACLE_EPOCH_SECONDS, SCHEMA_VERSION, STORAGE_PREFIX, calculatePositionGreeks, tickToSqrtPriceX96 } from "./greeks-GysWXct-.js";
+import { BaseError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, encodeFunctionData, getAddress, keccak256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
 
 //#region src/generated.ts
 const collateralTrackerV2Abi = [
@@ -8991,6 +8991,179 @@ const uniswapV3PoolAbi = [
 	}
 ];
 
+//#endregion
+//#region src/panoptic/v2/utils/oraclePack.ts
+const ORACLE_EPOCH_SHIFT = 232n;
+const ORACLE_EPOCH_MASK = (1n << 24n) - 1n;
+const ORACLE_TICK_MASK = (1n << 22n) - 1n;
+function decodeSigned22(value) {
+	const signBit = 1n << 21n;
+	const truncated = value & ORACLE_TICK_MASK;
+	return (truncated & signBit) === 0n ? truncated : truncated - (1n << 22n);
+}
+/**
+* Decode the 24-bit epoch stored at bits 232..255 of OraclePack.
+*
+* The packed timestamp is modulo 2^30 seconds and only identifies an absolute
+* Unix timestamp within the wrap window containing `blockTimestamp`. Supplying
+* the relevant block timestamp resolves it to the latest matching epoch at or
+* before that block, including across the epoch counter wraparound.
+*/
+function decodeOracleTiming(oraclePack, blockTimestamp) {
+	const epoch = oraclePack >> ORACLE_EPOCH_SHIFT & ORACLE_EPOCH_MASK;
+	const currentEpoch = oracleEpochAt(blockTimestamp);
+	const elapsedEpochs = currentEpoch - epoch & ORACLE_EPOCH_MASK;
+	const currentEpochTimestamp = blockTimestamp - blockTimestamp % ORACLE_EPOCH_SECONDS;
+	return {
+		epoch,
+		timestamp: currentEpochTimestamp - elapsedEpochs * ORACLE_EPOCH_SECONDS
+	};
+}
+/** Decode the fixed-width ticks and guardian state stored in OraclePack. */
+function decodeOraclePack(oraclePack, blockTimestamp) {
+	const timing = decodeOracleTiming(oraclePack, blockTimestamp);
+	return {
+		referenceTick: decodeSigned22(oraclePack >> 96n),
+		lockMode: oraclePack >> 118n & 3n,
+		spotEMA: decodeSigned22(oraclePack >> 120n),
+		fastEMA: decodeSigned22(oraclePack >> 142n),
+		slowEMA: decodeSigned22(oraclePack >> 164n),
+		eonsEMA: decodeSigned22(oraclePack >> 186n),
+		...timing
+	};
+}
+/** Return the contract's modulo-2^24 64-second epoch for a block timestamp. */
+function oracleEpochAt(timestamp) {
+	return timestamp / ORACLE_EPOCH_SECONDS & ORACLE_EPOCH_MASK;
+}
+
+//#endregion
+//#region src/panoptic/v2/utils/oracleSafeMode.ts
+const UINT24_MASK = (1n << 24n) - 1n;
+function absoluteDelta(left, right) {
+	return left >= right ? left - right : right - left;
+}
+function epochsForPeriod(period) {
+	return (period + ORACLE_EPOCH_SECONDS - 1n) / ORACLE_EPOCH_SECONDS;
+}
+/** Decode the four uint24 periods packed by RiskEngine.EMA_PERIODS(). */
+function decodeOracleRiskParameters(emaPeriods, maxTicksDelta, maxClampDelta) {
+	const decodedPeriods = {
+		spot: emaPeriods & UINT24_MASK,
+		fast: emaPeriods >> 24n & UINT24_MASK,
+		slow: emaPeriods >> 48n & UINT24_MASK,
+		eons: emaPeriods >> 72n & UINT24_MASK
+	};
+	if (decodedPeriods.spot === 0n || decodedPeriods.fast === 0n || decodedPeriods.slow === 0n || decodedPeriods.eons === 0n || maxTicksDelta <= 0n || maxClampDelta < 0n) throw new PanopticValidationError(`RiskEngine returned invalid oracle parameters: EMA_PERIODS=${emaPeriods}, MAX_TICKS_DELTA=${maxTicksDelta}, MAX_CLAMP_DELTA=${maxClampDelta}`);
+	return {
+		emaPeriods: decodedPeriods,
+		maxTicksDelta,
+		maxClampDelta
+	};
+}
+/** Explain the on-chain SafeMode level using this deployment's RiskEngine constants. */
+function diagnoseOracleSafeMode(state, parameters, onchainLevel) {
+	const externalShockDelta = absoluteDelta(state.currentTick, state.spotEMA);
+	const internalDisagreementDelta = absoluteDelta(state.spotEMA, state.fastEMA);
+	const highDivergenceDelta = absoluteDelta(state.medianTick, state.slowEMA);
+	const internalThreshold = parameters.maxTicksDelta / 2n;
+	const externalShock = externalShockDelta > parameters.maxTicksDelta;
+	const internalDisagreement = internalDisagreementDelta > internalThreshold;
+	const highDivergence = highDivergenceDelta > internalThreshold;
+	const guardianLocked = state.lockMode !== 0n;
+	const algorithmicLevel = (externalShock ? 1n : 0n) + (internalDisagreement ? 1n : 0n) + (highDivergence ? 1n : 0n);
+	const reproducedLevel = algorithmicLevel + state.lockMode;
+	const matchesOnchain = reproducedLevel === onchainLevel;
+	const causes = [];
+	if (matchesOnchain) {
+		if (externalShock) causes.push("externalShock");
+		if (internalDisagreement) causes.push("internalDisagreement");
+		if (highDivergence) causes.push("highDivergence");
+	} else causes.push("unknown");
+	if (guardianLocked) causes.push("guardianLock");
+	const candidateEpochs = [];
+	if (!matchesOnchain) candidateEpochs.push(1n);
+	if (highDivergence) candidateEpochs.push(1n);
+	if (externalShock) candidateEpochs.push(epochsForPeriod(parameters.emaPeriods.spot));
+	if (internalDisagreement) candidateEpochs.push(epochsForPeriod(parameters.emaPeriods.fast));
+	const minimumPokeEpochs = candidateEpochs.reduce((minimum, epochs) => minimum === 0n || epochs < minimum ? epochs : minimum, 0n);
+	return {
+		level: onchainLevel,
+		reproducedLevel,
+		matchesOnchain,
+		causes,
+		externalShockDelta,
+		internalDisagreementDelta,
+		highDivergenceDelta,
+		guardianLocked,
+		minimumPokeEpochs,
+		shouldPoke: onchainLevel > 0n && !guardianLocked
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/mintBuffer.ts
+/**
+* `RiskEngine.BP_DECREASE_BUFFER` — the numerator of the mint-time buffer.
+*
+* Exported so callers can display the constant; prefer {@link applyMintBuffer}
+* over multiplying by it directly, which is how the rounding bug reappears.
+*/
+const MINT_BUFFER = 10666667n;
+/** `RiskEngine.DECIMALS` — the denominator {@link MINT_BUFFER} is taken over. */
+const MINT_BUFFER_DENOMINATOR = 10000000n;
+/** The compiled-in default, matching the deployed RiskEngine. */
+const DEFAULT_MINT_BUFFER = {
+	numerator: MINT_BUFFER,
+	denominator: MINT_BUFFER_DENOMINATOR
+};
+/**
+* Apply the mint buffer to ONE token's NATIVE requirement, rounding up exactly
+* as `Math.mulDivRoundingUp` does on-chain.
+*
+* Call this on the native token0/token1 requirement, never on a quote-converted
+* total — see the module docstring for why the order matters.
+*
+* @param required - Maintenance requirement in that token's own units
+* @param buffer - Optional live on-chain ratio; defaults to {@link DEFAULT_MINT_BUFFER}
+* @returns The mint-time requirement the solvency check enforces
+*/
+function applyMintBuffer(required, buffer = DEFAULT_MINT_BUFFER) {
+	const { numerator, denominator } = buffer;
+	if (denominator <= 0n) throw new PanopticValidationError("applyMintBuffer: buffer denominator must be positive");
+	if (required <= 0n) return 0n;
+	return (required * numerator + denominator - 1n) / denominator;
+}
+/**
+* Apply the mint buffer to both tokens' NATIVE requirements, independently.
+*
+* This is the shape the solvency check itself uses: two separate per-side
+* comparisons, never a pooled total.
+*
+* @param required0 - Maintenance requirement in token0 units
+* @param required1 - Maintenance requirement in token1 units
+* @param buffer - Optional live on-chain ratio
+* @returns `[buffered0, buffered1]`
+*/
+function applyMintBufferPerToken(required0, required1, buffer = DEFAULT_MINT_BUFFER) {
+	return [applyMintBuffer(required0, buffer), applyMintBuffer(required1, buffer)];
+}
+/**
+* Collateral still deployable on one side before the mint solvency check fails:
+* `balance - bufferedRequired`, floored at zero.
+*
+* Both arguments must be in the SAME token's units.
+*
+* @param balance - That side's collateral balance
+* @param required - That side's maintenance requirement (unbuffered)
+* @param buffer - Optional live on-chain ratio
+* @returns Mintable headroom, never negative
+*/
+function mintableAfterBuffer(balance, required, buffer = DEFAULT_MINT_BUFFER) {
+	const requiredAtMint = applyMintBuffer(required, buffer);
+	return balance > requiredAtMint ? balance - requiredAtMint : 0n;
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/pool.ts
 const erc20Abi$1 = [
@@ -9132,13 +9305,28 @@ async function getPoolMetadata(params) {
 	const parsedPoolKey = parsePoolKey(poolKeyBytes);
 	let underlyingPoolId;
 	let fee;
+	let tickSpacing;
 	if (isV4) {
 		underlyingPoolId = keccak256(poolKeyBytes);
 		fee = parsedPoolKey.fee;
+		tickSpacing = tickSpacingFromPoolId(poolId);
 	} else {
 		const v3PoolAddress = decodeAbiParameters([{ type: "address" }], poolKeyBytes)[0];
 		underlyingPoolId = v3PoolAddress;
-		fee = await getV3PoolFee(client, v3PoolAddress);
+		const [v3Fee, v3TickSpacing] = await client.multicall({
+			contracts: [{
+				address: v3PoolAddress,
+				abi: uniswapV3PoolAbi,
+				functionName: "fee"
+			}, {
+				address: v3PoolAddress,
+				abi: uniswapV3PoolAbi,
+				functionName: "tickSpacing"
+			}],
+			allowFailure: false
+		});
+		fee = BigInt(v3Fee);
+		tickSpacing = BigInt(v3TickSpacing);
 	}
 	return {
 		poolKeyBytes,
@@ -9156,7 +9344,7 @@ async function getPoolMetadata(params) {
 		token0Name,
 		token1Name,
 		underlyingPoolId,
-		tickSpacing: tickSpacingFromPoolId(poolId),
+		tickSpacing,
 		fee,
 		sfpmAddress
 	};
@@ -9277,8 +9465,12 @@ async function getPool(params) {
 	const [currentTick, safeModeRaw, token0PoolData, token0TotalSupply, token0InterestRate, token1PoolData, token1TotalSupply, token1InterestRate, sellerCollateralRatio, maintMarginRate, notionalFee, premiumFee, vegoid$1, maxSpread] = coreResults.map((r) => r.result);
 	const liquidityResult = dynamicResults[14];
 	const uniswapPoolLiquidity = liquidityResult?.status === "success" ? BigInt(liquidityResult.result) : 0n;
-	const poolKey = parsePoolKey(metadata.poolKeyBytes);
-	const tickSpacing = tickSpacingFromPoolId(metadata.poolId);
+	const tickSpacing = metadata.tickSpacing;
+	const poolKey = {
+		...parsePoolKey(metadata.poolKeyBytes),
+		fee: metadata.fee,
+		tickSpacing
+	};
 	const SECONDS_PER_YEAR = 31536000n;
 	const borrowRate0 = BigInt(token0InterestRate) * SECONDS_PER_YEAR;
 	const borrowRate1 = BigInt(token1InterestRate) * SECONDS_PER_YEAR;
@@ -9443,32 +9635,73 @@ function availableToBorrow(poolData, totalSupply) {
 async function getOracleState(params) {
 	const { client, poolAddress, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
-	const [oracleTicks, _meta] = await Promise.all([client.readContract({
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "getOracleTicks",
+	const [[oracleTicks, twapTick], _meta] = await Promise.all([client.multicall({
+		contracts: [{
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "getOracleTicks"
+		}, {
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "getTWAP"
+		}],
+		allowFailure: false,
 		blockNumber: targetBlockNumber
 	}), params._meta ?? getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	})]);
 	const [currentTick, spotTick, medianTick, latestTick, oraclePack] = oracleTicks;
-	const epoch = oraclePack >> 208n & (1n << 32n) - 1n;
-	const lastUpdateTimestamp = oraclePack >> 176n & (1n << 32n) - 1n;
-	const lockMode = oraclePack >> 118n & 3n;
+	const decoded = decodeOraclePack(oraclePack, _meta.blockTimestamp);
 	return {
-		epoch,
-		lastUpdateTimestamp,
+		epoch: decoded.epoch,
+		lastUpdateTimestamp: decoded.timestamp,
 		referenceTick: BigInt(currentTick),
+		currentTick: BigInt(currentTick),
+		oracleReferenceTick: decoded.referenceTick,
+		latestTick: BigInt(latestTick),
+		twapTick: BigInt(twapTick),
 		spotEMA: BigInt(spotTick),
-		fastEMA: BigInt(latestTick),
-		slowEMA: BigInt(medianTick),
-		eonsEMA: 0n,
-		lockMode,
+		fastEMA: decoded.fastEMA,
+		slowEMA: decoded.slowEMA,
+		eonsEMA: decoded.eonsEMA,
+		lockMode: decoded.lockMode,
 		medianTick: BigInt(medianTick),
 		_meta
 	};
 }
+/** Read the oracle constants from a specific deployed RiskEngine. */
+async function getOracleRiskParameters(params) {
+	const targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+	const [[emaPeriods, maxTicksDelta, maxClampDelta], _meta] = await Promise.all([params.client.multicall({
+		contracts: [
+			{
+				address: params.riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "EMA_PERIODS"
+			},
+			{
+				address: params.riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "MAX_TICKS_DELTA"
+			},
+			{
+				address: params.riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "MAX_CLAMP_DELTA"
+			}
+		],
+		allowFailure: false,
+		blockNumber: targetBlockNumber
+	}), getBlockMeta({
+		client: params.client,
+		blockNumber: targetBlockNumber
+	})]);
+	return {
+		...decodeOracleRiskParameters(BigInt(emaPeriods), BigInt(maxTicksDelta), BigInt(maxClampDelta)),
+		_meta
+	};
+}
 /**
 * Get risk parameters from the pool.
 *
@@ -9519,6 +9752,16 @@ async function getRiskParameters(params) {
 				abi: riskEngineAbi,
 				functionName: "SATURATED_POOL_UTIL"
 			},
+			{
+				address: riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "BP_DECREASE_BUFFER"
+			},
+			{
+				address: riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "DECIMALS"
+			},
 			{
 				address: poolAddress,
 				abi: panopticPoolV2Abi,
@@ -9532,7 +9775,7 @@ async function getRiskParameters(params) {
 		client,
 		blockNumber: targetBlockNumber
 	})]);
-	const [sellerCollateralRatio, buyerCollateralRatio, maintMarginRate, notionalFee, targetPoolUtil, saturatedPoolUtil, ,] = riskEngineResults;
+	const [sellerCollateralRatio, buyerCollateralRatio, maintMarginRate, notionalFee, targetPoolUtil, saturatedPoolUtil, bpDecreaseBuffer, riskEngineDecimals, ,] = riskEngineResults;
 	return {
 		collateralRequirement: sellerCollateralRatio,
 		maintenanceMargin: maintMarginRate,
@@ -9540,6 +9783,10 @@ async function getRiskParameters(params) {
 		targetUtilization: targetPoolUtil,
 		saturatedUtilization: saturatedPoolUtil,
 		itmSpreadMultiplier: buyerCollateralRatio,
+		mintBuffer: BigInt(riskEngineDecimals) > 0n ? {
+			numerator: BigInt(bpDecreaseBuffer),
+			denominator: BigInt(riskEngineDecimals)
+		} : DEFAULT_MINT_BUFFER,
 		_meta
 	};
 }
@@ -9567,17 +9814,6 @@ async function validateBuilderCode(params) {
 	}
 }
 /**
-* Read the fee tier from a Uniswap V3 pool contract.
-*/
-async function getV3PoolFee(client, poolAddress) {
-	const fee = await client.readContract({
-		address: poolAddress,
-		abi: uniswapV3PoolAbi,
-		functionName: "fee"
-	});
-	return BigInt(fee);
-}
-/**
 * Extract tickSpacing from the encoded 64-bit poolId.
 * Layout: poolAddress (5 bytes) + vegoid (1 byte) + tickSpacing (2 bytes).
 * tickSpacing occupies bits 48–63.
@@ -9594,7 +9830,7 @@ function tickSpacingFromPoolId(poolId) {
 * V3 pools: poolKey() returns abi.encode(uniswapV3PoolAddress) — a single
 *   32-byte slot. The struct fields are not available, so currency0/currency1
 *   are zeroed and tickSpacing/fee are set to 0 (callers should use
-*   tickSpacingFromPoolId and getV3PoolFee respectively).
+*   getV3PoolTickSpacing and getV3PoolFee respectively).
 */
 function parsePoolKey(poolKeyBytes) {
 	const hex = poolKeyBytes.slice(2);
@@ -10105,5 +10341,821 @@ async function getPositionGreeks(params) {
 }
 
 //#endregion
-export { AccountInsolventError as AccountInsolventError$1, AlreadyInitializedError as AlreadyInitializedError$1, BatchValidationError as BatchValidationError$1, BelowMinimumRedemptionError as BelowMinimumRedemptionError$1, CastingError as CastingError$1, ChunkHasZeroLiquidityError as ChunkHasZeroLiquidityError$1, ChunkLimitError as ChunkLimitError$1, CrossPoolError as CrossPoolError$1, DEFAULT_MAX_SPREAD as DEFAULT_MAX_SPREAD$1, DEFAULT_VEGOID as DEFAULT_VEGOID$1, DepositTooLargeError as DepositTooLargeError$1, DuplicateTokenIdError as DuplicateTokenIdError$1, EffectiveLiquidityAboveThresholdError as EffectiveLiquidityAboveThresholdError$1, ExceedsMaximumRedemptionError as ExceedsMaximumRedemptionError$1, InputListFailError as InputListFailError$1, InsufficientCreditLiquidityError as InsufficientCreditLiquidityError$1, InvalidBuilderCodeError as InvalidBuilderCodeError$1, InvalidHistoryRangeError as InvalidHistoryRangeError$1, InvalidTickBoundError as InvalidTickBoundError$1, InvalidTickError as InvalidTickError$1, InvalidTickLimitsError, InvalidTokenIdParameterError as InvalidTokenIdParameterError$1, InvalidUniswapCallbackError as InvalidUniswapCallbackError$1, LEG_BITS as LEG_BITS$1, LEG_LIMITS as LEG_LIMITS$1, LEG_MASKS as LEG_MASKS$1, LengthMismatchError as LengthMismatchError$1, LiquidityTooHighError as LiquidityTooHighError$1, LoanSlotExhaustedError as LoanSlotExhaustedError$1, MaxRetriesExceededError as MaxRetriesExceededError$1, MissingPositionIdsError as MissingPositionIdsError$1, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError as NetLiquidityZeroError$1, NetworkMismatchError as NetworkMismatchError$1, NoLegsExercisableError as NoLegsExercisableError$1, NoLoanPositionsError, NotALongLegError as NotALongLegError$1, NotBuilderError as NotBuilderError$1, NotEnoughLiquidityInChunkError as NotEnoughLiquidityInChunkError$1, NotEnoughTokensError as NotEnoughTokensError$1, NotGuardianError as NotGuardianError$1, NotMarginCalledError as NotMarginCalledError$1, NotPanopticPoolError as NotPanopticPoolError$1, OracleRateLimitedError as OracleRateLimitedError$1, PanopticError, PanopticHelperNotDeployedError as PanopticHelperNotDeployedError$1, PanopticValidationError as PanopticValidationError$1, PoolNotInitializedError as PoolNotInitializedError$1, PositionCountNotZeroError as PositionCountNotZeroError$1, PositionNotOwnedError as PositionNotOwnedError$1, PositionSnapshotNotFoundError as PositionSnapshotNotFoundError$1, PositionTooLargeError as PositionTooLargeError$1, PriceBoundFailError as PriceBoundFailError$1, PriceImpactTooLargeError as PriceImpactTooLargeError$1, ProviderLagError as ProviderLagError$1, ReentrancyError as ReentrancyError$1, RpcError as RpcError$1, RpcResponseError as RpcResponseError$1, STANDARD_TICK_WIDTHS as STANDARD_TICK_WIDTHS$1, STRIKE_CONVERSION_FACTOR, SafeModeError as SafeModeError$1, StaleDataError as StaleDataError$1, StaleOracleError as StaleOracleError$1, StorageDataNotFoundError, SwapTokenMismatchError as SwapTokenMismatchError$1, SyncTimeoutError as SyncTimeoutError$1, TOKEN_ID_BITS as TOKEN_ID_BITS$1, TokenIdHasZeroLegsError as TokenIdHasZeroLegsError$1, TooManyLegsOpenError as TooManyLegsOpenError$1, TransferFailedError as TransferFailedError$1, UnauthorizedUniswapCallbackError as UnauthorizedUniswapCallbackError$1, UnderOverFlowError as UnderOverFlowError$1, UnhealthyPoolError as UnhealthyPoolError$1, WrongPoolIdError as WrongPoolIdError$1, WrongUniswapPoolError as WrongUniswapPoolError$1, ZeroAddressError as ZeroAddressError$1, ZeroCollateralRequirementError as ZeroCollateralRequirementError$1, collateralTrackerV2Abi, createTxResult, decodeLeftRightSigned as decodeLeftRightSigned$1, decodeLeftRightUnsigned as decodeLeftRightUnsigned$1, decodePosition, decodePositionBalance$1 as decodePositionBalance, decodeTickSpacing as decodeTickSpacing$1, fetchPoolId, getBlockMeta as getBlockMeta$1, getOracleState, getPool, getPoolMetadata, getPosition as getPosition$1, getPositionGreeks as getPositionGreeks$1, getPositions as getPositions$1, getRiskParameters, getUtilization, isPanopticErrorType as isPanopticErrorType$1, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError as parsePanopticError$1, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode };
-//# sourceMappingURL=position-C8rkkKhi.js.map
+//#region src/panoptic/v2/storage/fileStorage.ts
+/**
+* Creates a file-based storage adapter for Node.js environments.
+* Stores data as JSON files in the specified directory.
+*
+* The directory will be created if it doesn't exist.
+*
+* @param directory - Path to the storage directory
+*
+* @example
+* ```typescript
+* import { createFileStorage, createConfig } from 'panoptic-v2-sdk'
+*
+* // Node.js only
+* const config = createConfig({
+*   chainId: 1n,
+*   transport: http('...'),
+*   poolAddress: '0x...',
+*   storage: createFileStorage('./panoptic-cache'),
+* })
+* ```
+*/
+function createFileStorage(directory) {
+	let fsPromises = null;
+	let pathModule = null;
+	let initialized = false;
+	const ensureInitialized = async () => {
+		if (initialized) return;
+		fsPromises = await import("node:fs/promises");
+		pathModule = await import("node:path");
+		await fsPromises.mkdir(directory, { recursive: true });
+		initialized = true;
+	};
+	const getFilePath = (key) => {
+		if (!pathModule) throw new Error("File storage not initialized");
+		const safeKey = Buffer.from(key).toString("base64url");
+		return pathModule.join(directory, `${safeKey}.json`);
+	};
+	return {
+		async get(key) {
+			await ensureInitialized();
+			if (!fsPromises) throw new Error("File storage not initialized");
+			try {
+				const filePath = getFilePath(key);
+				const content = await fsPromises.readFile(filePath, "utf-8");
+				return content;
+			} catch (error) {
+				if (error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		async set(key, value) {
+			await ensureInitialized();
+			if (!fsPromises) throw new Error("File storage not initialized");
+			const filePath = getFilePath(key);
+			await fsPromises.writeFile(filePath, value, "utf-8");
+		},
+		async delete(key) {
+			await ensureInitialized();
+			if (!fsPromises) throw new Error("File storage not initialized");
+			try {
+				const filePath = getFilePath(key);
+				await fsPromises.unlink(filePath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		},
+		async has(key) {
+			await ensureInitialized();
+			if (!fsPromises) throw new Error("File storage not initialized");
+			try {
+				const filePath = getFilePath(key);
+				await fsPromises.access(filePath);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async keys(prefix) {
+			await ensureInitialized();
+			if (!fsPromises || !pathModule) throw new Error("File storage not initialized");
+			const result = [];
+			try {
+				const files = await fsPromises.readdir(directory);
+				for (const file of files) if (file.endsWith(".json")) {
+					const safeKey = file.slice(0, -5);
+					try {
+						const key = Buffer.from(safeKey, "base64url").toString();
+						if (key.startsWith(prefix)) result.push(key);
+					} catch {}
+				}
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			return result;
+		},
+		async clear(prefix) {
+			await ensureInitialized();
+			if (!fsPromises) throw new Error("File storage not initialized");
+			const keysToDelete = await this.keys(prefix);
+			for (const key of keysToDelete) await this.delete(key);
+		}
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/storage/keys.ts
+/**
+* Get the schema version key.
+*/
+function getSchemaVersionKey() {
+	return `${STORAGE_PREFIX}:schemaVersion`;
+}
+/**
+* Get the base prefix for a specific pool.
+*/
+function getPoolPrefix(chainId, poolAddress) {
+	return `${STORAGE_PREFIX}:v${SCHEMA_VERSION}:chain${chainId}:pool${poolAddress.toLowerCase()}`;
+}
+/**
+* Get the key for tracked position IDs.
+*/
+function getPositionsKey(chainId, poolAddress, account) {
+	return `${getPoolPrefix(chainId, poolAddress)}:positions:${account.toLowerCase()}`;
+}
+/**
+* Get the key for position mint metadata.
+*/
+function getPositionMetaKey(chainId, poolAddress, tokenId) {
+	return `${getPoolPrefix(chainId, poolAddress)}:positionMeta:${tokenId.toString()}`;
+}
+/**
+* Get the key for sync checkpoint.
+*/
+function getSyncCheckpointKey(chainId, poolAddress, account) {
+	return `${getPoolPrefix(chainId, poolAddress)}:sync:${account.toLowerCase()}`;
+}
+/**
+* Get the key for closed positions.
+*/
+function getClosedPositionsKey(chainId, poolAddress, account) {
+	return `${getPoolPrefix(chainId, poolAddress)}:closed:${account.toLowerCase()}`;
+}
+/**
+* Get the key for tracked chunks.
+*/
+function getTrackedChunksKey(chainId, poolAddress) {
+	return `${getPoolPrefix(chainId, poolAddress)}:chunks`;
+}
+/**
+* Get the key for pending positions.
+*/
+function getPendingPositionsKey(chainId, poolAddress, account) {
+	return `${getPoolPrefix(chainId, poolAddress)}:pending:${account.toLowerCase()}`;
+}
+/**
+* Get the key for pool metadata (tickSpacing, etc.).
+*/
+function getPoolMetaKey(chainId, poolAddress) {
+	return `${getPoolPrefix(chainId, poolAddress)}:poolMeta`;
+}
+
+//#endregion
+//#region src/panoptic/v2/storage/memoryStorage.ts
+/**
+* Creates an in-memory storage adapter.
+* Useful for testing and development.
+*
+* Data is lost when the process exits.
+*
+* @example
+* ```typescript
+* import { createMemoryStorage, createConfig } from 'panoptic-v2-sdk'
+*
+* const config = createConfig({
+*   chainId: 1n,
+*   transport: http('...'),
+*   poolAddress: '0x...',
+*   storage: createMemoryStorage(),
+* })
+* ```
+*/
+function createMemoryStorage() {
+	const store = new Map();
+	return {
+		async get(key) {
+			return store.get(key) ?? null;
+		},
+		async set(key, value) {
+			store.set(key, value);
+		},
+		async delete(key) {
+			store.delete(key);
+		},
+		async has(key) {
+			return store.has(key);
+		},
+		async keys(prefix) {
+			const result = [];
+			for (const key of store.keys()) if (key.startsWith(prefix)) result.push(key);
+			return result;
+		},
+		async clear(prefix) {
+			const keysToDelete = [];
+			for (const key of store.keys()) if (key.startsWith(prefix)) keysToDelete.push(key);
+			for (const key of keysToDelete) store.delete(key);
+		}
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/storage/serializer.ts
+/**
+* Type guard to check if a value is a tagged BigInt.
+*/
+function isBigIntTagged(value) {
+	return value !== null && typeof value === "object" && "__type" in value && value.__type === "bigint" && "value" in value && typeof value.value === "string";
+}
+/**
+* Replacer function for JSON.stringify that tags BigInt values.
+*/
+function replacer(_key, value) {
+	if (typeof value === "bigint") return {
+		__type: "bigint",
+		value: value.toString()
+	};
+	return value;
+}
+/**
+* Reviver function for JSON.parse that restores tagged BigInt values.
+*/
+function reviver(_key, value) {
+	if (isBigIntTagged(value)) return BigInt(value.value);
+	return value;
+}
+/**
+* BigInt-safe JSON serializer for the Panoptic v2 SDK.
+*
+* This serializer handles BigInt values by tagging them with a special format
+* that can be restored on parse. The format is compatible with superjson
+* patterns used in Next.js and Remix for SSR hydration.
+*
+* @example
+* ```typescript
+* import { jsonSerializer } from 'panoptic-v2-sdk'
+*
+* const data = { amount: 1000000000000000000n, nested: { value: 42n } }
+*
+* // Serialize to JSON string
+* const json = jsonSerializer.stringify(data)
+* // '{"amount":{"__type":"bigint","value":"1000000000000000000"},"nested":{"value":{"__type":"bigint","value":"42"}}}'
+*
+* // Parse back to original types
+* const parsed = jsonSerializer.parse(json)
+* // { amount: 1000000000000000000n, nested: { value: 42n } }
+* ```
+*/
+const jsonSerializer = {
+	stringify(value, space) {
+		return JSON.stringify(value, replacer, space);
+	},
+	parse(text) {
+		return JSON.parse(text, reviver);
+	}
+};
+
+//#endregion
+//#region src/panoptic/v2/sync/snapshotRecovery.ts
+const LOG_SCAN_WINDOW = 10000n;
+const rolesExecutionAbi = parseAbi(["function execTransactionWithRole(address to, uint256 value, bytes data, uint8 operation, bytes32 roleKey, bool shouldRevert)"]);
+/**
+* Recover position snapshot from the last dispatch transaction.
+* This is the primary recovery method - it finds the most recent dispatch()
+* call and extracts the finalPositionIdList from the calldata.
+*
+* @param params - Recovery parameters
+* @returns Snapshot recovery result
+*/
+async function recoverSnapshot(params) {
+	const { client, poolAddress, account, toBlock } = params;
+	const latestBlock = toBlock ?? await client.getBlockNumber();
+	const searchFromBlock = params.fromBlock ?? 0n;
+	if (latestBlock < searchFromBlock) return null;
+	try {
+		const events = await getSnapshotEventsForWindow({
+			client,
+			poolAddress,
+			account,
+			fromBlock: searchFromBlock,
+			toBlock: latestBlock
+		});
+		return await recoverSnapshotFromEvents({
+			client,
+			account,
+			events
+		});
+	} catch (error) {
+		if (!isRangeLimitError(error)) throw error;
+	}
+	let windowToBlock = latestBlock;
+	while (true) {
+		const windowFromBlock = windowToBlock - searchFromBlock + 1n > LOG_SCAN_WINDOW ? windowToBlock - LOG_SCAN_WINDOW + 1n : searchFromBlock;
+		const events = await getSnapshotEventsForWindow({
+			client,
+			poolAddress,
+			account,
+			fromBlock: windowFromBlock,
+			toBlock: windowToBlock
+		});
+		const snapshot = await recoverSnapshotFromEvents({
+			client,
+			account,
+			events
+		});
+		if (snapshot) return snapshot;
+		if (windowFromBlock === searchFromBlock) break;
+		windowToBlock = windowFromBlock - 1n;
+	}
+	return null;
+}
+/**
+* Detect provider errors that indicate the requested getLogs block range was
+* too wide (so the caller should retry with smaller windows). Covers the common
+* phrasings used by Alchemy, Infura, and other JSON-RPC providers.
+*/
+function isRangeLimitError(error) {
+	const parts = [];
+	let current = error;
+	let depth = 0;
+	while (current && typeof current === "object" && depth < 5) {
+		const obj = current;
+		if (typeof obj.message === "string") parts.push(obj.message);
+		if (typeof obj.details === "string") parts.push(obj.details);
+		current = obj.cause;
+		depth += 1;
+	}
+	if (typeof error === "string") parts.push(error);
+	const message = parts.join(" ").toLowerCase();
+	if (!message) return false;
+	return message.includes("block range") || message.includes("range is too large") || message.includes("range too large") || message.includes("query returned more than") || message.includes("too many results") || message.includes("log response size exceeded") || message.includes("exceeds the limit") || message.includes("range") && message.includes("limit");
+}
+async function getSnapshotEventsForWindow(params) {
+	const { client, poolAddress, account, fromBlock, toBlock } = params;
+	const [mintEvents, burnEvents, forceExerciseEvents, liquidationEvents] = await Promise.all([
+		client.getLogs({
+			address: poolAddress,
+			event: {
+				type: "event",
+				name: "OptionMinted",
+				inputs: [
+					{
+						type: "address",
+						name: "recipient",
+						indexed: true
+					},
+					{
+						type: "uint256",
+						name: "tokenId",
+						indexed: true
+					},
+					{
+						type: "uint256",
+						name: "balanceData",
+						indexed: false
+					}
+				]
+			},
+			args: { recipient: account },
+			fromBlock,
+			toBlock
+		}),
+		client.getLogs({
+			address: poolAddress,
+			event: {
+				type: "event",
+				name: "OptionBurnt",
+				inputs: [
+					{
+						type: "address",
+						name: "recipient",
+						indexed: true
+					},
+					{
+						type: "uint128",
+						name: "positionSize",
+						indexed: false
+					},
+					{
+						type: "uint256",
+						name: "tokenId",
+						indexed: true
+					},
+					{
+						type: "int256[4]",
+						name: "premiaByLeg",
+						indexed: false
+					}
+				]
+			},
+			args: { recipient: account },
+			fromBlock,
+			toBlock
+		}),
+		client.getLogs({
+			address: poolAddress,
+			event: {
+				type: "event",
+				name: "ForcedExercised",
+				inputs: [
+					{
+						type: "address",
+						name: "exercisor",
+						indexed: true
+					},
+					{
+						type: "address",
+						name: "user",
+						indexed: true
+					},
+					{
+						type: "uint256",
+						name: "tokenId",
+						indexed: true
+					},
+					{
+						type: "int256",
+						name: "exerciseFee",
+						indexed: false
+					}
+				]
+			},
+			args: { user: account },
+			fromBlock,
+			toBlock
+		}),
+		client.getLogs({
+			address: poolAddress,
+			event: {
+				type: "event",
+				name: "AccountLiquidated",
+				inputs: [
+					{
+						type: "address",
+						name: "liquidator",
+						indexed: true
+					},
+					{
+						type: "address",
+						name: "liquidatee",
+						indexed: true
+					},
+					{
+						type: "int256",
+						name: "bonusAmounts",
+						indexed: false
+					}
+				]
+			},
+			args: { liquidatee: account },
+			fromBlock,
+			toBlock
+		})
+	]);
+	return [
+		...mintEvents,
+		...burnEvents,
+		...forceExerciseEvents,
+		...liquidationEvents
+	];
+}
+async function recoverSnapshotFromEvents(params) {
+	const { client, account, events } = params;
+	const allEvents = events.filter(isSnapshotCandidateEvent).sort((a, b) => {
+		const blockDiff = Number(b.blockNumber - a.blockNumber);
+		if (blockDiff !== 0) return blockDiff;
+		return Number(b.logIndex - a.logIndex);
+	});
+	const seen = new Set();
+	const uniqueEvents = allEvents.filter((e) => {
+		if (seen.has(e.transactionHash)) return false;
+		seen.add(e.transactionHash);
+		return true;
+	});
+	for (const event of uniqueEvents) try {
+		const [tx, block] = await Promise.all([client.getTransaction({ hash: event.transactionHash }), client.getBlock({ blockNumber: event.blockNumber })]);
+		const candidates = decodeAllDispatchCalldata(tx.input);
+		const decoded = selectDispatchForAccount(candidates, account, tx.from) ?? selectDispatchProvenByAccountEvent(candidates);
+		if (!decoded) continue;
+		return {
+			success: true,
+			positionIds: decoded.positionIds,
+			blockNumber: event.blockNumber,
+			blockHash: block.hash,
+			transactionHash: event.transactionHash
+		};
+	} catch {}
+	return null;
+}
+function isSnapshotCandidateEvent(event) {
+	return event.transactionHash !== null && event.blockNumber !== null && event.logIndex !== null;
+}
+function decodeSnapshotTransaction(params) {
+	const { account, pool, rolesContext } = params;
+	let dispatchInput = params.input;
+	let dispatchSender = params.from;
+	if (rolesContext) {
+		if (params.to === null || getAddress(params.to) !== getAddress(rolesContext.modifier) || getAddress(params.from) !== getAddress(rolesContext.member)) return null;
+		try {
+			const decodedRoleCall = decodeFunctionData({
+				abi: rolesExecutionAbi,
+				data: params.input
+			});
+			const [target, value, data, operation, roleKey, shouldRevert] = decodedRoleCall.args;
+			if (!pool || getAddress(target) !== getAddress(pool) || value !== 0n || operation !== 0 || roleKey.toLowerCase() !== rolesContext.roleKey.toLowerCase() || !shouldRevert) return null;
+			dispatchInput = data;
+			if (!account) return null;
+			dispatchSender = account;
+		} catch {
+			return null;
+		}
+	} else if (pool && (params.to === null || getAddress(params.to) !== getAddress(pool))) return null;
+	const candidates = decodeAllDispatchCalldata(dispatchInput);
+	if (candidates.length === 0) return null;
+	return account ? selectDispatchForAccount(candidates, account, dispatchSender) : candidates[candidates.length - 1];
+}
+/**
+* Recover position snapshot from a specific dispatch transaction hash.
+*
+* This is an O(1) alternative to {@link recoverSnapshot} when you already
+* know the tx hash of the most recent dispatch. It fetches the transaction,
+* decodes the `finalPositionIdList` from the calldata, and returns the result
+* — no event scanning required.
+*
+* @param params - Recovery parameters including the transaction hash
+* @returns Snapshot recovery result, or null if the tx is not a dispatch call
+*
+* @example
+* ```typescript
+* const snapshot = await recoverSnapshotFromTx({
+*   client,
+*   transactionHash: '0xabc...',
+* })
+* if (snapshot) {
+*   console.log('Open positions:', snapshot.positionIds)
+* }
+* ```
+*/
+async function recoverSnapshotFromTx(params) {
+	const { client, transactionHash, account, pool, rolesContext } = params;
+	const tx = await client.getTransaction({ hash: transactionHash });
+	if (tx.blockNumber == null) return null;
+	const decoded = decodeSnapshotTransaction({
+		input: tx.input,
+		from: tx.from,
+		to: tx.to,
+		account,
+		pool,
+		rolesContext
+	});
+	if (!decoded) return null;
+	const blockNumber = tx.blockNumber;
+	const block = await client.getBlock({ blockNumber });
+	return {
+		success: true,
+		positionIds: decoded.positionIds,
+		blockNumber,
+		blockHash: block.hash,
+		transactionHash
+	};
+}
+/**
+* Decode position IDs from dispatch calldata.
+*
+* When the tx embeds multiple dispatch/dispatchFrom calls (e.g. a force-exercise
+* multicall), this returns the last one — prefer {@link decodeAllDispatchCalldata}
+* plus {@link selectDispatchForAccount} when the account context matters.
+*
+* @param input - Transaction input data
+* @returns Decoded dispatch data or null if not a dispatch call
+*/
+function decodeDispatchCalldata(input) {
+	const all = decodeAllDispatchCalldata(input);
+	return all.length > 0 ? all[all.length - 1] : null;
+}
+/**
+* Decode every dispatch/dispatchFrom call embedded in transaction calldata.
+*
+* A single tx can carry more than one such call — most importantly a force-exercise
+* `multicall` that bundles the exercisor's own `dispatch` together with the victim's
+* `dispatchFrom`. Returning all candidates lets the caller select the one attributable
+* to the relevant account ({@link selectDispatchForAccount}).
+*
+* @param input - Transaction input data
+* @returns All decoded dispatch calls, in calldata order (may be empty)
+*/
+function decodeAllDispatchCalldata(input) {
+	const direct = decodeDirectDispatch(input);
+	if (direct) return [direct];
+	return decodeWrappedDispatch(input);
+}
+/**
+* Select the dispatch call attributable to `account` from a set of candidates.
+*
+* - `dispatchFrom`: matches when `targetAccount === account` (builder/exercisor acting
+*   on behalf of the account).
+* - `dispatch` (no `targetAccount`): matches only when the tx sender is the account.
+*
+* Returns the LAST matching candidate (in calldata order), or null when none are
+* attributable to `account`. The last dispatch reflects the final post-transaction
+* state when a single tx contains multiple dispatches for the same account (e.g. a
+* multicall). Matching also prevents accepting a third party's `dispatch` (e.g. the
+* exercisor's own, bundled in a force-exercise multicall) as the account's snapshot.
+*
+* @param candidates - Decoded dispatch calls from a single tx, in calldata order
+* @param account - Account whose position list we are recovering
+* @param txFrom - The transaction sender (`tx.from`)
+*/
+function selectDispatchForAccount(candidates, account, txFrom) {
+	const acct = account.toLowerCase();
+	let match = null;
+	for (const candidate of candidates) if (candidate.targetAccount) {
+		if (candidate.targetAccount.toLowerCase() === acct) match = candidate;
+	} else if (txFrom.toLowerCase() === acct) match = candidate;
+	return match;
+}
+function selectDispatchProvenByAccountEvent(candidates) {
+	let match = null;
+	for (const candidate of candidates) if (candidate.targetAccount === void 0) match = candidate;
+	return match;
+}
+/**
+* Try to decode input as a direct dispatch or dispatchFrom call.
+*/
+function decodeDirectDispatch(input) {
+	try {
+		const decoded = decodeFunctionData({
+			abi: panopticPoolV2Abi,
+			data: input
+		});
+		if (decoded.functionName === "dispatch") {
+			const args = decoded.args;
+			return { positionIds: [...args[1]] };
+		}
+		if (decoded.functionName === "dispatchFrom") {
+			const args = decoded.args;
+			return {
+				positionIds: [...args[3]],
+				targetAccount: args[1]
+			};
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 4-byte function selectors for dispatch/dispatchFrom, derived from the generated ABI.
+* Used for scanning raw calldata inside smart contract wallet wrappers.
+*/
+const DISPATCH_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatch")).slice(2);
+const DISPATCH_FROM_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatchFrom")).slice(2);
+/**
+* Scan raw transaction input for embedded dispatch calldata.
+*
+* Smart contract wallets (Safe, Turnkey, ERC-4337) and vault managers
+* wrap dispatch calls inside executeBatch → manage → dispatch chains.
+* Instead of decoding each wrapper layer, we scan the raw hex for the
+* dispatch function selector and attempt to decode from that offset.
+*
+* This handles arbitrary nesting depth without knowing wrapper ABIs.
+*/
+function decodeWrappedDispatch(input) {
+	const hex = input.slice(2).toLowerCase();
+	const selectors = [DISPATCH_SELECTOR, DISPATCH_FROM_SELECTOR];
+	const results = [];
+	let offset = 0;
+	while (offset < hex.length) {
+		let earliestIdx = -1;
+		for (const selector of selectors) {
+			const idx = hex.indexOf(selector, offset);
+			if (idx !== -1 && (earliestIdx === -1 || idx < earliestIdx)) earliestIdx = idx;
+		}
+		if (earliestIdx === -1) break;
+		const candidate = `0x${hex.slice(earliestIdx)}`;
+		const result = decodeDirectDispatch(candidate);
+		if (result) results.push(result);
+		offset = earliestIdx + 8;
+	}
+	return results;
+}
+
+//#endregion
+//#region src/panoptic/v2/sync/getTrackedPositionIds.ts
+/**
+* Verify that a recovered position-id list still matches the account's current
+* on-chain state. `getFullPositionsData` reverts when the list contains a
+* tokenId the account no longer holds, so a successful call is proof the list
+* is live. Returns `false` on revert so the caller can fall back to an
+* authoritative event scan instead of trusting a stale checkpoint.
+*/
+async function isPositionListLive(params) {
+	const { client, poolAddress, account, positionIds, blockNumber } = params;
+	if (positionIds.length === 0) return true;
+	try {
+		await client.readContract({
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				false,
+				positionIds
+			],
+			blockNumber
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get all tracked position IDs for an account from local cache.
+*
+* This function reads from the storage adapter without making RPC calls.
+* The positions returned may include closed positions if the cache is stale.
+* Use `getPositions()` for authoritative on-chain data.
+*
+* @param params - Query parameters
+* @returns Array of position token IDs
+*/
+async function getTrackedPositionIds(params) {
+	const { chainId, poolAddress, account, storage } = params;
+	const key = getPositionsKey(chainId, poolAddress, account);
+	const data = await storage.get(key);
+	if (!data) return [];
+	try {
+		const positionIds = jsonSerializer.parse(data);
+		return positionIds;
+	} catch {
+		return [];
+	}
+}
+/**
+* Check if a specific position ID is tracked.
+*
+* @param params - Query parameters
+* @param tokenId - Token ID to check
+* @returns Whether the position is tracked
+*/
+async function isPositionTracked(params, tokenId) {
+	const positionIds = await getTrackedPositionIds(params);
+	return positionIds.some((id) => id === tokenId);
+}
+/**
+* Clear all tracked positions for an account.
+*
+* @param params - Query parameters
+*/
+async function clearTrackedPositions(params) {
+	const { chainId, poolAddress, account, storage } = params;
+	const key = getPositionsKey(chainId, poolAddress, account);
+	await storage.delete(key);
+}
+/**
+* Get the authoritative list of open position IDs from the chain.
+*
+* Recovers the `finalPositionIdList` from the account's most recent
+* `dispatch()` transaction calldata. This is the on-chain–validated set of
+* open positions (verified against `s_positionsHash` by the contract) and
+* requires only a few RPC calls regardless of account history length.
+*
+* This is the recommended way to get position IDs for `existingPositionIds`
+* (openPosition) and `positionIdList` (closePosition).
+*
+* If `storage` is provided, the local cache is updated with the result.
+*
+* @param params - Query parameters
+* @returns Array of currently open position token IDs, or null if no snapshot was found
+*/
+async function getOpenPositionIds(params) {
+	const { client, chainId, poolAddress, account, storage, lastDispatchTxHash, fromBlock, toBlock, rolesContext } = params;
+	let snapshot = null;
+	if (lastDispatchTxHash) try {
+		const candidate = await recoverSnapshotFromTx({
+			client,
+			transactionHash: lastDispatchTxHash,
+			account,
+			pool: poolAddress,
+			rolesContext
+		});
+		if (candidate && await isPositionListLive({
+			client,
+			poolAddress,
+			account,
+			positionIds: candidate.positionIds,
+			blockNumber: toBlock
+		})) snapshot = candidate;
+	} catch {
+		snapshot = null;
+	}
+	if (!snapshot) snapshot = await recoverSnapshot({
+		client,
+		poolAddress,
+		account,
+		fromBlock,
+		toBlock
+	});
+	if (!snapshot) return null;
+	if (storage) {
+		const key = getPositionsKey(chainId, poolAddress, account);
+		await storage.set(key, jsonSerializer.stringify(snapshot.positionIds));
+	}
+	return snapshot.positionIds;
+}
+
+//#endregion
+export { AccountInsolventError as AccountInsolventError$1, AlreadyInitializedError as AlreadyInitializedError$1, BatchValidationError as BatchValidationError$1, BelowMinimumRedemptionError as BelowMinimumRedemptionError$1, CastingError as CastingError$1, ChunkHasZeroLiquidityError as ChunkHasZeroLiquidityError$1, ChunkLimitError as ChunkLimitError$1, CrossPoolError as CrossPoolError$1, DEFAULT_MAX_SPREAD as DEFAULT_MAX_SPREAD$1, DEFAULT_MINT_BUFFER as DEFAULT_MINT_BUFFER$1, DEFAULT_VEGOID as DEFAULT_VEGOID$1, DepositTooLargeError as DepositTooLargeError$1, DuplicateTokenIdError as DuplicateTokenIdError$1, EffectiveLiquidityAboveThresholdError as EffectiveLiquidityAboveThresholdError$1, ExceedsMaximumRedemptionError as ExceedsMaximumRedemptionError$1, InputListFailError as InputListFailError$1, InsufficientCreditLiquidityError as InsufficientCreditLiquidityError$1, InvalidBuilderCodeError as InvalidBuilderCodeError$1, InvalidHistoryRangeError as InvalidHistoryRangeError$1, InvalidTickBoundError as InvalidTickBoundError$1, InvalidTickError as InvalidTickError$1, InvalidTickLimitsError, InvalidTokenIdParameterError as InvalidTokenIdParameterError$1, InvalidUniswapCallbackError as InvalidUniswapCallbackError$1, LEG_BITS as LEG_BITS$1, LEG_LIMITS as LEG_LIMITS$1, LEG_MASKS as LEG_MASKS$1, LengthMismatchError as LengthMismatchError$1, LiquidityTooHighError as LiquidityTooHighError$1, LoanSlotExhaustedError as LoanSlotExhaustedError$1, MINT_BUFFER as MINT_BUFFER$1, MINT_BUFFER_DENOMINATOR as MINT_BUFFER_DENOMINATOR$1, MaxRetriesExceededError as MaxRetriesExceededError$1, MissingPositionIdsError as MissingPositionIdsError$1, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError as NetLiquidityZeroError$1, NetworkMismatchError as NetworkMismatchError$1, NoLegsExercisableError as NoLegsExercisableError$1, NoLoanPositionsError, NotALongLegError as NotALongLegError$1, NotBuilderError as NotBuilderError$1, NotEnoughLiquidityInChunkError as NotEnoughLiquidityInChunkError$1, NotEnoughTokensError as NotEnoughTokensError$1, NotGuardianError as NotGuardianError$1, NotMarginCalledError as NotMarginCalledError$1, NotPanopticPoolError as NotPanopticPoolError$1, OracleRateLimitedError as OracleRateLimitedError$1, PanopticError as PanopticError$1, PanopticHelperNotDeployedError as PanopticHelperNotDeployedError$1, PanopticValidationError as PanopticValidationError$1, PoolNotInitializedError as PoolNotInitializedError$1, PositionCountNotZeroError as PositionCountNotZeroError$1, PositionNotOwnedError as PositionNotOwnedError$1, PositionSnapshotNotFoundError as PositionSnapshotNotFoundError$1, PositionTooLargeError as PositionTooLargeError$1, PriceBoundFailError as PriceBoundFailError$1, PriceImpactTooLargeError as PriceImpactTooLargeError$1, ProviderLagError as ProviderLagError$1, ReentrancyError as ReentrancyError$1, RpcError as RpcError$1, RpcResponseError as RpcResponseError$1, STANDARD_TICK_WIDTHS as STANDARD_TICK_WIDTHS$1, STRIKE_CONVERSION_FACTOR, SafeModeError as SafeModeError$1, StaleDataError as StaleDataError$1, StaleOracleError as StaleOracleError$1, StorageDataNotFoundError, SwapTokenMismatchError as SwapTokenMismatchError$1, SyncTimeoutError as SyncTimeoutError$1, TOKEN_ID_BITS as TOKEN_ID_BITS$1, TokenIdHasZeroLegsError as TokenIdHasZeroLegsError$1, TooManyLegsOpenError as TooManyLegsOpenError$1, TransferFailedError as TransferFailedError$1, UnauthorizedUniswapCallbackError as UnauthorizedUniswapCallbackError$1, UnderOverFlowError as UnderOverFlowError$1, UnhealthyPoolError as UnhealthyPoolError$1, WrongPoolIdError as WrongPoolIdError$1, WrongUniswapPoolError as WrongUniswapPoolError$1, ZeroAddressError as ZeroAddressError$1, ZeroCollateralRequirementError as ZeroCollateralRequirementError$1, applyMintBuffer as applyMintBuffer$1, applyMintBufferPerToken as applyMintBufferPerToken$1, clearTrackedPositions as clearTrackedPositions$1, collateralTrackerV2Abi, createFileStorage as createFileStorage$1, createMemoryStorage as createMemoryStorage$1, createTxResult, decodeAllDispatchCalldata as decodeAllDispatchCalldata$1, decodeDispatchCalldata as decodeDispatchCalldata$1, decodeLeftRightSigned as decodeLeftRightSigned$1, decodeLeftRightUnsigned as decodeLeftRightUnsigned$1, decodeOraclePack as decodeOraclePack$1, decodeOracleRiskParameters as decodeOracleRiskParameters$1, decodeOracleTiming as decodeOracleTiming$1, decodePosition, decodePositionBalance$1 as decodePositionBalance, decodeTickSpacing as decodeTickSpacing$1, diagnoseOracleSafeMode as diagnoseOracleSafeMode$1, fetchPoolId as fetchPoolId$1, getBlockMeta as getBlockMeta$1, getClosedPositionsKey as getClosedPositionsKey$1, getOpenPositionIds as getOpenPositionIds$1, getOracleRiskParameters as getOracleRiskParameters$1, getOracleState as getOracleState$1, getPendingPositionsKey as getPendingPositionsKey$1, getPool as getPool$1, getPoolMetaKey as getPoolMetaKey$1, getPoolMetadata as getPoolMetadata$1, getPoolPrefix as getPoolPrefix$1, getPosition as getPosition$1, getPositionGreeks as getPositionGreeks$1, getPositionMetaKey as getPositionMetaKey$1, getPositions as getPositions$1, getPositionsKey as getPositionsKey$1, getRiskParameters as getRiskParameters$1, getSchemaVersionKey as getSchemaVersionKey$1, getSyncCheckpointKey as getSyncCheckpointKey$1, getTrackedChunksKey as getTrackedChunksKey$1, getTrackedPositionIds as getTrackedPositionIds$1, getUtilization as getUtilization$1, isPanopticErrorType as isPanopticErrorType$1, isPositionTracked as isPositionTracked$1, jsonSerializer as jsonSerializer$1, mintableAfterBuffer as mintableAfterBuffer$1, oracleEpochAt as oracleEpochAt$1, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError as parsePanopticError$1, recoverSnapshot as recoverSnapshot$1, recoverSnapshotFromTx as recoverSnapshotFromTx$1, riskEngineAbi, selectDispatchForAccount as selectDispatchForAccount$1, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode as validateBuilderCode$1 };
+//# sourceMappingURL=getTrackedPositionIds-zYPIs5dt.js.map