@panoptic-eng/sdk 1.0.36 → 1.0.38

package/dist/{writes-AupZCK4M.js → writes-D3bj1wth.js}

@@ -1,6 +1,6 @@
-import { BatchValidationError$1 as BatchValidationError, DEFAULT_VEGOID$1 as DEFAULT_VEGOID, InputListFailError$1 as InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError$1 as InvalidTokenIdParameterError, LEG_BITS$1 as LEG_BITS, LEG_LIMITS$1 as LEG_LIMITS, LEG_MASKS$1 as LEG_MASKS, LoanSlotExhaustedError$1 as LoanSlotExhaustedError, MaxRetriesExceededError$1 as MaxRetriesExceededError, MissingPositionIdsError$1 as MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError$1 as OracleRateLimitedError, PanopticError, ProviderLagError$1 as ProviderLagError, STRIKE_CONVERSION_FACTOR, SafeModeError$1 as SafeModeError, StaleDataError$1 as StaleDataError, SwapTokenMismatchError$1 as SwapTokenMismatchError, SyncTimeoutError$1 as SyncTimeoutError, TOKEN_ID_BITS$1 as TOKEN_ID_BITS, UnhealthyPoolError$1 as UnhealthyPoolError, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, getBlockMeta$1 as getBlockMeta, getPool, getPoolMetadata, getPositions$1 as getPositions, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError$1 as parsePanopticError, submitWrite } from "./position-C8rkkKhi.js";
-import { REORG_DEPTH, SCHEMA_VERSION, STORAGE_PREFIX, calculatePositionGreeks, tickLimits } from "./greeks-GysWXct-.js";
-import { decodeFunctionData, decodeFunctionResult, encodeFunctionData, erc20Abi, getAddress, parseAbi, toFunctionSelector } from "viem";
+import { BatchValidationError$1 as BatchValidationError, DEFAULT_VEGOID$1 as DEFAULT_VEGOID, InputListFailError$1 as InputListFailError, InvalidTickLimitsError, InvalidTokenIdParameterError$1 as InvalidTokenIdParameterError, LEG_BITS$1 as LEG_BITS, LEG_LIMITS$1 as LEG_LIMITS, LEG_MASKS$1 as LEG_MASKS, LoanSlotExhaustedError$1 as LoanSlotExhaustedError, MaxRetriesExceededError$1 as MaxRetriesExceededError, MissingPositionIdsError$1 as MissingPositionIdsError, NoLoanPositionsError, OracleRateLimitedError$1 as OracleRateLimitedError, PanopticError$1 as PanopticError, PositionSnapshotNotFoundError$1 as PositionSnapshotNotFoundError, ProviderLagError$1 as ProviderLagError, STRIKE_CONVERSION_FACTOR, SwapTokenMismatchError$1 as SwapTokenMismatchError, SyncTimeoutError$1 as SyncTimeoutError, TOKEN_ID_BITS$1 as TOKEN_ID_BITS, collateralTrackerV2Abi, createTxResult, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, decodeOracleTiming$1 as decodeOracleTiming, getBlockMeta$1 as getBlockMeta, getOpenPositionIds$1 as getOpenPositionIds, getPool$1 as getPool, getPoolMetaKey$1 as getPoolMetaKey, getPoolMetadata$1 as getPoolMetadata, getPositionMetaKey$1 as getPositionMetaKey, getPositions$1 as getPositions, getPositionsKey$1 as getPositionsKey, getSyncCheckpointKey$1 as getSyncCheckpointKey, getTrackedPositionIds$1 as getTrackedPositionIds, jsonSerializer$1 as jsonSerializer, oracleEpochAt$1 as oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticPoolV2Abi, parsePanopticError$1 as parsePanopticError, submitWrite } from "./getTrackedPositionIds-zYPIs5dt.js";
+import { REORG_DEPTH, calculatePositionGreeks, tickLimits } from "./greeks-GysWXct-.js";
+import { decodeFunctionResult, encodeFunctionData, erc20Abi, getAbiItem } from "viem";
 
 //#region src/panoptic/v2/writes/broadcaster.ts
 /**
@@ -341,822 +341,6 @@ async function redeemAndWait(params) {
 	return result.wait();
 }
 
-//#endregion
-//#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
 //#region src/panoptic/v2/writes/position.ts
 /**
@@ -1694,231 +878,158 @@ async function liquidateAndWait(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/bot/index.ts
-/**
-* Assert that data is fresh (not stale).
-*
-* Throws StaleDataError if the data's block timestamp is older than maxAgeSeconds.
-*
-* @param data - Any SDK data with _meta field
-* @param maxAgeSeconds - Maximum allowed age in seconds
-* @param currentTimestamp - Current timestamp (defaults to Date.now() / 1000)
-* @throws StaleDataError if data is stale
-*
-* @example
-* ```typescript
-* const pool = await getPool({ client, poolAddress })
-* assertFresh(pool, 60) // Must be < 60 seconds old
-* ```
-*/
-function assertFresh(data, maxAgeSeconds, currentTimestamp) {
-	const maxAge = BigInt(maxAgeSeconds);
-	const now = currentTimestamp !== void 0 ? BigInt(currentTimestamp) : BigInt(Math.floor(Date.now() / 1e3));
-	const blockTimestamp = data._meta.blockTimestamp;
-	const age = now - blockTimestamp;
-	if (age > maxAge) throw new StaleDataError(blockTimestamp, now, age);
-}
-/**
-* Assert that a pool is healthy.
-*
-* Throws UnhealthyPoolError if the pool health status is not 'active'.
-*
-* @param pool - Pool data from getPool()
-* @throws UnhealthyPoolError if pool is unhealthy (low_liquidity or paused)
-*
-* @example
-* ```typescript
-* const pool = await getPool({ client, poolAddress })
-* assertHealthy(pool) // Throws if pool is paused or has low liquidity
-* ```
-*/
-function assertHealthy(pool) {
-	if (pool.healthStatus !== "active") throw new UnhealthyPoolError(pool.healthStatus);
-}
-/**
-* Assert that trading is allowed on a pool.
-*
-* Checks both pool health and safe mode status. Throws appropriate errors
-* if trading is restricted.
-*
-* @param pool - Pool data from getPool()
-* @param safeMode - Optional SafeModeState from getSafeMode()
-* @throws UnhealthyPoolError if pool is unhealthy
-* @throws SafeModeError if pool is in restricted or emergency safe mode
-*
-* @example
-* ```typescript
-* const pool = await getPool({ client, poolAddress })
-* const safeMode = await getSafeMode({ client, poolAddress })
-* assertTradeable(pool, safeMode)
-* ```
-*/
-function assertTradeable(pool, safeMode) {
-	assertHealthy(pool);
-	if (safeMode && safeMode.mode !== "normal") throw new SafeModeError(safeMode.mode, safeMode.reason ?? "Trading restricted");
-}
-/**
-* Assert that minting is allowed.
-*
-* @param safeMode - SafeModeState from getSafeMode()
-* @throws SafeModeError if minting is not allowed
-*
-* @example
-* ```typescript
-* const safeMode = await getSafeMode({ client, poolAddress })
-* assertCanMint(safeMode)
-* await openPosition({ ... })
-* ```
-*/
-function assertCanMint(safeMode) {
-	if (!safeMode.canMint) throw new SafeModeError(safeMode.mode, safeMode.reason ?? "Minting not allowed");
-}
-/**
-* Assert that burning is allowed.
-*
-* @param safeMode - SafeModeState from getSafeMode()
-* @throws SafeModeError if burning is not allowed
-*/
-function assertCanBurn(safeMode) {
-	if (!safeMode.canBurn) throw new SafeModeError(safeMode.mode, safeMode.reason ?? "Burning not allowed");
-}
-/**
-* Assert that liquidations are allowed.
-*
-* @param safeMode - SafeModeState from getSafeMode()
-* @throws SafeModeError if liquidations are not allowed
-*/
-function assertCanLiquidate(safeMode) {
-	if (!safeMode.canLiquidate) throw new SafeModeError(safeMode.mode, safeMode.reason ?? "Liquidations not allowed");
-}
-/**
-* Assert that force exercise is allowed.
-*
-* @param safeMode - SafeModeState from getSafeMode()
-* @throws SafeModeError if force exercise is not allowed
-*/
-function assertCanForceExercise(safeMode) {
-	if (!safeMode.canForceExercise) throw new SafeModeError(safeMode.mode, safeMode.reason ?? "Force exercise not allowed");
-}
-/**
-* Common retryable RPC error codes.
-*/
-const RETRYABLE_RPC_CODES = new Set([
-	-32e3,
-	-32001,
-	-32002,
-	-32003,
-	-32005,
-	-32097,
-	-32098,
-	-32099
-]);
-/**
-* Common retryable error message patterns.
-*/
-const RETRYABLE_PATTERNS = [
-	/timeout/i,
-	/timed out/i,
-	/rate limit/i,
-	/too many requests/i,
-	/429/i,
-	/503/i,
-	/504/i,
-	/502/i,
-	/connection refused/i,
-	/connection reset/i,
-	/network error/i,
-	/econnreset/i,
-	/econnrefused/i,
-	/etimedout/i,
-	/socket hang up/i,
-	/temporarily unavailable/i,
-	/service unavailable/i,
-	/server error/i,
-	/internal error/i,
-	/nonce too low/i,
-	/replacement transaction underpriced/i,
-	/already known/i
-];
-/**
-* Check if an error is a retryable RPC error.
-*
-* Returns true for transient errors that may succeed on retry:
-* - Timeouts
-* - Rate limits
-* - Connection errors
-* - Server errors (5xx)
-* - Nonce errors (recoverable with correct nonce)
-*
-* @param error - The error to check
-* @returns True if the error is likely retryable
-*
-* @example
-* ```typescript
-* try {
-*   await openPosition({ ... })
-* } catch (error) {
-*   if (isRetryableRpcError(error)) {
-*     // Wait and retry
-*     await sleep(1000)
-*     await openPosition({ ... })
-*   } else {
-*     throw error // Non-retryable, propagate
-*   }
-* }
-* ```
-*/
-function isRetryableRpcError(error) {
-	if (error === null || error === void 0) return false;
-	if (typeof error === "object") {
-		const errorObj = error;
-		if (typeof errorObj.code === "number" && RETRYABLE_RPC_CODES.has(errorObj.code)) return true;
-		if (errorObj.cause && isRetryableRpcError(errorObj.cause)) return true;
-		if (errorObj.details && typeof errorObj.details === "object") {
-			const details = errorObj.details;
-			if (typeof details.code === "number" && RETRYABLE_RPC_CODES.has(details.code)) return true;
+//#region src/panoptic/v2/sync/eventReconstruction.ts
+/**
+* Reconstruct position history from events.
+* This is the fallback method when snapshot recovery fails.
+* It scans all OptionMinted and OptionBurnt events to build the position set.
+*
+* @param params - Reconstruction parameters
+* @returns Reconstruction result with open and closed positions
+*/
+async function reconstructFromEvents(params) {
+	const { client, poolAddress, account, fromBlock, toBlock, batchSize = 10000n, onProgress } = params;
+	const mintEvents = [];
+	const burnEvents = [];
+	const totalBlocks = toBlock - fromBlock + 1n;
+	const safeBatchSize = batchSize > 0n ? batchSize : 10000n;
+	const scanRange = async (rangeFromBlock, rangeToBlock) => {
+		const [mints, burns] = await Promise.all([client.getLogs({
+			address: poolAddress,
+			event: OPTION_MINTED_EVENT,
+			args: { recipient: account },
+			fromBlock: rangeFromBlock,
+			toBlock: rangeToBlock
+		}), client.getLogs({
+			address: poolAddress,
+			event: OPTION_BURNT_EVENT,
+			args: { recipient: account },
+			fromBlock: rangeFromBlock,
+			toBlock: rangeToBlock
+		})]);
+		for (const mint$1 of mints) {
+			const balanceData = mint$1.args.balanceData;
+			const positionSize = balanceData & (1n << 128n) - 1n;
+			mintEvents.push({
+				tokenId: mint$1.args.tokenId,
+				positionSize,
+				blockNumber: mint$1.blockNumber,
+				blockHash: mint$1.blockHash,
+				transactionHash: mint$1.transactionHash,
+				logIndex: mint$1.logIndex
+			});
+		}
+		for (const burn of burns) burnEvents.push({
+			tokenId: burn.args.tokenId,
+			positionSize: burn.args.positionSize,
+			blockNumber: burn.blockNumber,
+			blockHash: burn.blockHash,
+			transactionHash: burn.transactionHash,
+			logIndex: burn.logIndex
+		});
+		const blocksProcessed = rangeToBlock - fromBlock + 1n;
+		const progress = totalBlocks > 0n ? blocksProcessed * 100n / totalBlocks : 100n;
+		onProgress?.({
+			currentBlock: rangeToBlock,
+			targetBlock: toBlock,
+			positionsFound: BigInt(mintEvents.length),
+			progress: progress > 100n ? 100n : progress
+		});
+	};
+	try {
+		await scanRange(fromBlock, toBlock);
+	} catch (error) {
+		if (!isRangeLimitError(error)) throw error;
+		let currentBlock = fromBlock;
+		while (currentBlock <= toBlock) {
+			const endBlock = currentBlock + safeBatchSize - 1n > toBlock ? toBlock : currentBlock + safeBatchSize - 1n;
+			await scanRange(currentBlock, endBlock);
+			currentBlock = endBlock + 1n;
 		}
 	}
-	const message = getErrorMessage(error);
-	if (message) {
-		for (const pattern of RETRYABLE_PATTERNS) if (pattern.test(message)) return true;
+	const positionMap = new Map();
+	const allEvents = [...mintEvents.map((e) => ({
+		...e,
+		type: "mint"
+	})), ...burnEvents.map((e) => ({
+		...e,
+		type: "burn"
+	}))].sort((a, b) => {
+		const blockDiff = Number(a.blockNumber - b.blockNumber);
+		if (blockDiff !== 0) return blockDiff;
+		return a.logIndex - b.logIndex;
+	});
+	for (const event of allEvents) {
+		const current = positionMap.get(event.tokenId) ?? 0n;
+		if (event.type === "mint") positionMap.set(event.tokenId, current + event.positionSize);
+		else positionMap.set(event.tokenId, current - event.positionSize);
 	}
-	return false;
+	const openPositions = [];
+	const closedPositions = [];
+	for (const [tokenId, size] of positionMap) if (size > 0n) openPositions.push(tokenId);
+	else closedPositions.push(tokenId);
+	const lastBlock = await client.getBlock({ blockNumber: toBlock });
+	return {
+		openPositions,
+		closedPositions,
+		blocksScanned: toBlock - fromBlock + 1n,
+		lastBlock: toBlock,
+		lastBlockHash: lastBlock.hash
+	};
 }
-/**
-* Extract error message from various error types.
-*/
-function getErrorMessage(error) {
-	if (typeof error === "string") return error;
-	if (error instanceof Error) return error.message;
-	if (typeof error === "object" && error !== null) {
-		const errorObj = error;
-		if (typeof errorObj.message === "string") return errorObj.message;
-		if (typeof errorObj.shortMessage === "string") return errorObj.shortMessage;
+const OPTION_MINTED_EVENT = getAbiItem({
+	abi: panopticPoolV2Abi,
+	name: "OptionMinted"
+});
+const OPTION_BURNT_EVENT = getAbiItem({
+	abi: panopticPoolV2Abi,
+	name: "OptionBurnt"
+});
+function isRangeLimitError(error) {
+	const messages = [];
+	let current = error;
+	for (let depth = 0; current && typeof current === "object" && depth < 5; depth += 1) {
+		if ("message" in current && typeof current.message === "string") messages.push(current.message);
+		if ("details" in current && typeof current.details === "string") messages.push(current.details);
+		current = "cause" in current ? current.cause : void 0;
 	}
-	return void 0;
-}
-/**
-* Check if an error is a nonce-related error that can be recovered.
-*
-* @param error - The error to check
-* @returns True if this is a nonce error
-*/
-function isNonceError(error) {
-	const message = getErrorMessage(error);
-	if (!message) return false;
-	return /nonce too low/i.test(message) || /nonce too high/i.test(message) || /already known/i.test(message);
+	if (typeof error === "string") messages.push(error);
+	const message = messages.join(" ").toLowerCase();
+	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");
 }
 /**
-* Check if an error is a gas-related error that can be recovered.
+* Get the deployment block for a pool.
+* This searches for the first PoolInitialized event.
 *
-* @param error - The error to check
-* @returns True if this is a gas error
-*/
-function isGasError(error) {
-	const message = getErrorMessage(error);
-	if (!message) return false;
-	return /replacement transaction underpriced/i.test(message) || /gas too low/i.test(message) || /intrinsic gas too low/i.test(message) || /max fee per gas less than block base fee/i.test(message);
+* @param client - viem public client
+* @param poolAddress - Pool address
+* @returns Deployment block number or null if not found
+*/
+async function getPoolDeploymentBlock(client, poolAddress) {
+	const currentBlock = await client.getBlockNumber();
+	let low = 0n;
+	let high = currentBlock;
+	let foundBlock = null;
+	const scanRange = 10000n;
+	while (low <= high) {
+		const mid = (low + high) / 2n;
+		const rangeEnd = mid + scanRange > high ? high : mid + scanRange;
+		try {
+			const logs = await client.getLogs({
+				address: poolAddress,
+				fromBlock: mid,
+				toBlock: rangeEnd
+			});
+			if (logs.length > 0) {
+				const earliest = logs[0].blockNumber;
+				if (foundBlock === null || earliest < foundBlock) foundBlock = earliest;
+				high = earliest - 1n;
+			} else low = rangeEnd + 1n;
+		} catch {
+			high = mid + (rangeEnd - mid) / 2n;
+		}
+	}
+	return foundBlock;
 }
 
 //#endregion
@@ -2087,47 +1198,45 @@ async function syncPositions(params) {
 		fromBlock: checkpoint?.lastBlock ?? params.fromBlock
 	});
 	let positionIds;
-	if (snapshotResult === null && checkpoint && checkpoint.positionIds.length > 0) positionIds = checkpoint.positionIds;
-	else positionIds = snapshotResult ?? [];
-	if (positionIds.length === 0) {
-		const hasAnyEvents = await accountHasPositionEvents({
+	if (snapshotResult === null) {
+		const fromBlock = params.fromBlock ?? await getPoolDeploymentBlock(client, poolAddress);
+		if (fromBlock === null) throw new PositionSnapshotNotFoundError(new Error("Pool deployment block not found"));
+		const reconstruction = await reconstructFromEvents({
 			client,
 			poolAddress,
 			account,
-			fromBlock: params.fromBlock,
-			toBlock
+			fromBlock,
+			toBlock,
+			batchSize: params.maxLogsPerQuery,
+			onProgress: (progress) => {
+				checkTimeout();
+				onUpdate?.({
+					type: "progress",
+					blockNumber: progress.currentBlock,
+					progress: {
+						current: progress.currentBlock,
+						total: progress.targetBlock
+					}
+				});
+			}
 		});
-		if (!hasAnyEvents) {
-			const finalBlock$1 = await client.getBlock({ blockNumber: toBlock });
-			const poolMetaKey$1 = getPoolMetaKey(chainId, poolAddress);
-			const existingPoolMeta$1 = await storage.get(poolMetaKey$1);
-			if (!existingPoolMeta$1) await fetchAndStorePoolMeta(client, poolAddress, poolMetaKey$1, storage);
-			await saveCheckpoint({
-				storage,
-				chainId,
-				poolAddress,
-				account,
-				lastBlock: toBlock,
-				lastBlockHash: finalBlock$1.hash,
-				positionIds: []
-			});
-			const positionsKey$1 = getPositionsKey(chainId, poolAddress, account);
-			await storage.set(positionsKey$1, jsonSerializer.stringify([]));
-			return {
-				lastSyncedBlock: toBlock,
-				lastSyncedBlockHash: finalBlock$1.hash,
-				positionCount: 0n,
-				positionIds: [],
-				incremental: false,
-				durationMs: BigInt(Date.now() - startTime)
-			};
-		}
+		positionIds = reconstruction.openPositions;
+	} else positionIds = snapshotResult;
+	const finalBlock = await client.getBlock({ blockNumber: toBlock });
+	if (positionIds.length === 0) {
+		await persistPoolAndCheckpoint(params, toBlock, finalBlock.hash, []);
+		const positionsKey$1 = getPositionsKey(chainId, poolAddress, account);
+		await storage.set(positionsKey$1, jsonSerializer.stringify([]));
+		return {
+			lastSyncedBlock: toBlock,
+			lastSyncedBlockHash: finalBlock.hash,
+			positionCount: 0n,
+			positionIds: [],
+			incremental: !!checkpoint,
+			durationMs: BigInt(Date.now() - startTime)
+		};
 	}
 	checkTimeout();
-	const finalBlock = await client.getBlock({ blockNumber: toBlock });
-	const poolMetaKey = getPoolMetaKey(chainId, poolAddress);
-	const existingPoolMeta = await storage.get(poolMetaKey);
-	if (!existingPoolMeta) await fetchAndStorePoolMeta(client, poolAddress, poolMetaKey, storage);
 	if (positionIds.length > 0) {
 		const { positions } = await getPositions({
 			client,
@@ -2152,15 +1261,7 @@ async function syncPositions(params) {
 			await storage.set(positionMetaKey, jsonSerializer.stringify(storedData));
 		}
 	}
-	await saveCheckpoint({
-		storage,
-		chainId,
-		poolAddress,
-		account,
-		lastBlock: toBlock,
-		lastBlockHash: finalBlock.hash,
-		positionIds
-	});
+	await persistPoolAndCheckpoint(params, toBlock, finalBlock.hash, positionIds);
 	const positionsKey = getPositionsKey(chainId, poolAddress, account);
 	await storage.set(positionsKey, jsonSerializer.stringify(positionIds));
 	return {
@@ -2172,143 +1273,20 @@ async function syncPositions(params) {
 		durationMs: BigInt(Date.now() - startTime)
 	};
 }
-/**
-* Quick check if an account has ANY position events.
-* Checks OptionMinted, OptionBurnt, ForcedExercised (user), and AccountLiquidated (liquidatee).
-* All checked fields are indexed so this is fast.
-*
-* **Warning:** RPC index lag can cause false negatives for recently minted positions.
-* If the RPC node's event index is behind the chain tip, this function may return
-* `false` even though the account has just minted a position. Callers should either
-* wait a few blocks after minting before calling syncPositions, or skip this
-* optimization (by providing a `snapshotTxHash`) when freshness is critical.
-*
-* @param params - Check parameters
-* @returns true if account has any position events, false otherwise
-*/
-async function accountHasPositionEvents(params) {
-	const { client, poolAddress, account, fromBlock = 0n, toBlock } = params;
-	const [mintEvents, burnEvents, forceExerciseEvents, liquidationEvents] = await Promise.all([
-		withRetry(() => 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
-		})),
-		withRetry(() => client.getLogs({
-			address: poolAddress,
-			event: {
-				type: "event",
-				name: "OptionBurnt",
-				inputs: [
-					{
-						type: "address",
-						name: "recipient",
-						indexed: true
-					},
-					{
-						type: "uint256",
-						name: "tokenId",
-						indexed: true
-					},
-					{
-						type: "uint256",
-						name: "positionSize",
-						indexed: false
-					},
-					{
-						type: "int256[4]",
-						name: "premiaByLeg",
-						indexed: false
-					}
-				]
-			},
-			args: { recipient: account },
-			fromBlock,
-			toBlock
-		})),
-		withRetry(() => 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
-		})),
-		withRetry(() => 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.length > 0 || burnEvents.length > 0 || forceExerciseEvents.length > 0 || liquidationEvents.length > 0;
+async function persistPoolAndCheckpoint(params, lastBlock, lastBlockHash, positionIds) {
+	const { account, chainId, client, poolAddress, storage } = params;
+	const poolMetaKey = getPoolMetaKey(chainId, poolAddress);
+	const existingPoolMeta = await storage.get(poolMetaKey);
+	if (!existingPoolMeta) await fetchAndStorePoolMeta(client, poolAddress, poolMetaKey, storage);
+	await saveCheckpoint({
+		storage,
+		chainId,
+		poolAddress,
+		account,
+		lastBlock,
+		lastBlockHash,
+		positionIds
+	});
 }
 /**
 * Fetch full pool metadata and store it.
@@ -2335,27 +1313,6 @@ async function fetchAndStorePoolMeta(client, poolAddress, poolMetaKey, storage)
 	};
 	await storage.set(poolMetaKey, jsonSerializer.stringify(poolMeta));
 }
-/**
-* Retry helper with exponential backoff for transient RPC errors.
-*
-* @param fn - Async function to retry
-* @param maxRetries - Maximum number of retries (default: 3)
-* @returns The result of the function
-*/
-async function withRetry(fn, maxRetries = 3) {
-	let lastError;
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-		return await fn();
-	} catch (error) {
-		lastError = error;
-		if (attempt < maxRetries && isRetryableRpcError(error)) {
-			await new Promise((resolve) => setTimeout(resolve, 1e3 * 2 ** attempt));
-			continue;
-		}
-		throw error;
-	}
-	throw lastError;
-}
 
 //#endregion
 //#region src/panoptic/v2/writes/forceExercise.ts
@@ -2515,10 +1472,10 @@ async function pokeOracle(params) {
 			functionName: "getOracleTicks"
 		}), client.getBlock()]);
 		const oraclePack = oracleData[4];
-		const epoch = oraclePack >> 232n;
-		const currentEpoch = block.timestamp / 64n;
-		if (currentEpoch <= epoch) {
-			const lastUpdate = epoch * 64n;
+		const { epoch } = decodeOracleTiming(oraclePack, block.timestamp);
+		const currentEpoch = oracleEpochAt(block.timestamp);
+		if (currentEpoch === epoch) {
+			const lastUpdate = epoch << 6n;
 			throw new OracleRateLimitedError(lastUpdate, block.timestamp);
 		}
 	}
@@ -3139,6 +2096,44 @@ function buildUniqueCredit(poolId, asset, tokenType, currentTick, tickSpacing, e
 
 //#endregion
 //#region src/panoptic/v2/writes/swap.ts
+/** Build an atomic credit mint/burn swap without fetching or sending anything. */
+function buildCreditSwapCall(params) {
+	const amount = params.kind === "exactIn" ? params.amountIn : params.amountOut;
+	if (amount <= 0n) throw new Error("credit swap amount must be positive");
+	if (params.tokenIndex !== 0n && params.tokenIndex !== 1n) throw new Error("credit swap tokenIndex must be 0 or 1");
+	const { low, high } = tickLimits(params.currentTick, params.slippageBps);
+	const { tokenId: creditTokenId, adjustedSize } = buildUniqueCredit(params.poolId, params.tokenIndex, params.tokenIndex, params.currentTick, params.tickSpacing, params.existingPositionIds, amount);
+	const ascending = [
+		Number(low),
+		Number(high),
+		0
+	];
+	const descending = [
+		Number(high),
+		Number(low),
+		0
+	];
+	const limits = params.kind === "exactIn" ? [ascending, descending] : [descending, ascending];
+	const args = [
+		[creditTokenId, creditTokenId],
+		[...params.existingPositionIds],
+		[adjustedSize, 0n],
+		limits,
+		false,
+		params.builderCode ?? 0n
+	];
+	return {
+		to: params.poolAddress,
+		data: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "dispatch",
+			args
+		}),
+		creditTokenId,
+		adjustedSize,
+		args
+	};
+}
 /**
 * Swap tokens using Panoptic's exact-output mechanism.
 *
@@ -3172,22 +2167,18 @@ async function swapExactOut(params) {
 		const token0 = pool.collateralTracker0.token;
 		const token1 = pool.collateralTracker1.token;
 		const tokenOutIndex = resolveTokenIndex(tokenOut, token0, token1);
-		const tokenType = tokenOutIndex;
-		const { low: tickLimitLow, high: tickLimitHigh } = tickLimits(pool.currentTick, slippageBps);
-		const { tokenId: creditTokenId, adjustedSize } = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenType, pool.currentTick, pool.tickSpacing, positionIds, amountOut);
-		const mintTickLimits = [
-			Number(tickLimitHigh),
-			Number(tickLimitLow),
-			0
-		];
-		const burnTickLimits = [
-			Number(tickLimitLow),
-			Number(tickLimitHigh),
-			0
-		];
-		const positionIdList = [creditTokenId, creditTokenId];
-		const finalPositionIdList = [...positionIds];
-		const positionSizes = [adjustedSize, 0n];
+		const call = buildCreditSwapCall({
+			kind: "exactOut",
+			poolAddress,
+			poolId: pool.poolId,
+			currentTick: pool.currentTick,
+			tickSpacing: pool.tickSpacing,
+			existingPositionIds: positionIds,
+			tokenIndex: tokenOutIndex,
+			amountOut,
+			slippageBps,
+			builderCode
+		});
 		try {
 			return await submitWrite({
 				client,
@@ -3196,14 +2187,7 @@ async function swapExactOut(params) {
 				address: poolAddress,
 				abi: panopticPoolV2Abi,
 				functionName: "dispatch",
-				args: [
-					positionIdList,
-					finalPositionIdList,
-					positionSizes,
-					[mintTickLimits, burnTickLimits],
-					false,
-					builderCode
-				],
+				args: call.args,
 				txOverrides
 			});
 		} catch (error) {
@@ -3253,22 +2237,18 @@ async function swapExactIn(params) {
 		const token0 = pool.collateralTracker0.token;
 		const token1 = pool.collateralTracker1.token;
 		const tokenInIndex = resolveTokenIndex(tokenIn, token0, token1);
-		const tokenType = tokenInIndex;
-		const { low: tickLimitLow, high: tickLimitHigh } = tickLimits(pool.currentTick, slippageBps);
-		const { tokenId: creditTokenId, adjustedSize } = buildUniqueCredit(pool.poolId, tokenInIndex, tokenType, pool.currentTick, pool.tickSpacing, positionIds, amountIn);
-		const mintTickLimits = [
-			Number(tickLimitLow),
-			Number(tickLimitHigh),
-			0
-		];
-		const burnTickLimits = [
-			Number(tickLimitHigh),
-			Number(tickLimitLow),
-			0
-		];
-		const positionIdList = [creditTokenId, creditTokenId];
-		const finalPositionIdList = [...positionIds];
-		const positionSizes = [adjustedSize, 0n];
+		const call = buildCreditSwapCall({
+			kind: "exactIn",
+			poolAddress,
+			poolId: pool.poolId,
+			currentTick: pool.currentTick,
+			tickSpacing: pool.tickSpacing,
+			existingPositionIds: positionIds,
+			tokenIndex: tokenInIndex,
+			amountIn,
+			slippageBps,
+			builderCode
+		});
 		try {
 			return await submitWrite({
 				client,
@@ -3277,14 +2257,7 @@ async function swapExactIn(params) {
 				address: poolAddress,
 				abi: panopticPoolV2Abi,
 				functionName: "dispatch",
-				args: [
-					positionIdList,
-					finalPositionIdList,
-					positionSizes,
-					[mintTickLimits, burnTickLimits],
-					false,
-					builderCode
-				],
+				args: call.args,
 				txOverrides
 			});
 		} catch (error) {
@@ -3873,6 +2846,67 @@ async function simulateWithTokenFlow(params) {
 		};
 	}
 }
+/**
+* Get pool token addresses for reference.
+*
+* @param params - Parameters
+* @returns Pool token addresses
+*/
+async function getPoolTokensForSimulation(params) {
+	const { client, poolAddress, blockNumber } = params;
+	const poolAbi = [{
+		type: "function",
+		name: "collateralToken0",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}, {
+		type: "function",
+		name: "collateralToken1",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}];
+	const collateralAbi = [{
+		type: "function",
+		name: "asset",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}];
+	const [ct0, ct1] = await client.multicall({
+		contracts: [{
+			address: poolAddress,
+			abi: poolAbi,
+			functionName: "collateralToken0"
+		}, {
+			address: poolAddress,
+			abi: poolAbi,
+			functionName: "collateralToken1"
+		}],
+		blockNumber,
+		allowFailure: false
+	});
+	const [token0, token1] = await client.multicall({
+		contracts: [{
+			address: ct0,
+			abi: collateralAbi,
+			functionName: "asset"
+		}, {
+			address: ct1,
+			abi: collateralAbi,
+			functionName: "asset"
+		}],
+		blockNumber,
+		allowFailure: false
+	});
+	return {
+		token0,
+		token1,
+		collateralTracker0: ct0,
+		collateralTracker1: ct1
+	};
+}
 
 //#endregion
 //#region src/panoptic/v2/simulations/simulateOpenPosition.ts
@@ -4572,5 +3606,5 @@ async function smartRepayAndWait(params) {
 }
 
 //#endregion
-export { addLegToTokenId as addLegToTokenId$1, approve as approve$1, approveAndWait as approveAndWait$1, approvePool as approvePool$1, assertCanBurn as assertCanBurn$1, assertCanForceExercise as assertCanForceExercise$1, assertCanLiquidate as assertCanLiquidate$1, assertCanMint as assertCanMint$1, assertFresh as assertFresh$1, assertHealthy as assertHealthy$1, assertTradeable as assertTradeable$1, borrow as borrow$1, borrowAndWait as borrowAndWait$1, buildBatchDispatchArgs as buildBatchDispatchArgs$1, buildOpenPositionCalldata as buildOpenPositionCalldata$1, buildUniqueCredit as buildUniqueCredit$1, buildUniqueLoan as buildUniqueLoan$1, buildUniqueWidthZeroLeg as buildUniqueWidthZeroLeg$1, calculateResyncBlock as calculateResyncBlock$1, cancelTransaction as cancelTransaction$1, checkApproval as checkApproval$1, clearCheckpoint as clearCheckpoint$1, clearTrackedPositions as clearTrackedPositions$1, closePosition as closePosition$1, closePositionAndWait as closePositionAndWait$1, countLegs as countLegs$1, createFileStorage as createFileStorage$1, createMemoryStorage as createMemoryStorage$1, createNonceManager as createNonceManager$1, createTokenIdBuilder as createTokenIdBuilder$1, decodeAllDispatchCalldata as decodeAllDispatchCalldata$1, decodeAllLegs as decodeAllLegs$1, decodeDispatchCalldata as decodeDispatchCalldata$1, decodeLeg as decodeLeg$1, decodePoolId as decodePoolId$1, decodeTickSpacing as decodeTickSpacing$2, decodeTokenId as decodeTokenId$1, decodeVegoid as decodeVegoid$1, deployNewPool as deployNewPool$1, deployNewPoolAndWait as deployNewPoolAndWait$1, deposit as deposit$1, depositAndWait as depositAndWait$1, detectReorg as detectReorg$1, dispatch as dispatch$1, dispatchAndWait as dispatchAndWait$1, encodeLeg as encodeLeg$1, encodePoolId as encodePoolId$1, encodeV4PoolId as encodeV4PoolId$1, executeBatchDispatch as executeBatchDispatch$1, executeBatchDispatchAndWait as executeBatchDispatchAndWait$1, forceExercise as forceExercise$1, forceExerciseAndWait as forceExerciseAndWait$1, getAssetIndex as getAssetIndex$1, getClosedPositionsKey as getClosedPositionsKey$1, getOpenPositionIds as getOpenPositionIds$1, getPendingPositionsKey as getPendingPositionsKey$1, getPoolMetaKey as getPoolMetaKey$1, getPoolPrefix as getPoolPrefix$1, getPositionMetaKey as getPositionMetaKey$1, getPositionsKey as getPositionsKey$1, getSchemaVersionKey as getSchemaVersionKey$1, getSyncCheckpointKey as getSyncCheckpointKey$1, getTrackedChunksKey as getTrackedChunksKey$1, getTrackedPositionIds as getTrackedPositionIds$1, hasLoanOrCredit as hasLoanOrCredit$1, hasLongLeg as hasLongLeg$1, isCredit as isCredit$1, isCreditLeg as isCreditLeg$1, isGasError as isGasError$1, isInputListFailError as isInputListFailError$1, isLoan as isLoan$1, isLoanLeg as isLoanLeg$1, isNonceError as isNonceError$1, isPositionTracked as isPositionTracked$1, isRetryableRpcError as isRetryableRpcError$1, isShortOnly as isShortOnly$1, isSpread as isSpread$1, jsonSerializer as jsonSerializer$1, liquidate as liquidate$1, liquidateAndWait as liquidateAndWait$1, loadCheckpoint as loadCheckpoint$1, mint as mint$1, mintAndWait as mintAndWait$1, openPosition as openPosition$1, openPositionAndWait as openPositionAndWait$1, pokeOracle as pokeOracle$1, pokeOracleAndWait as pokeOracleAndWait$1, previewBorrow as previewBorrow$1, previewUnwrap as previewUnwrap$1, previewWrap as previewWrap$1, publicBroadcaster as publicBroadcaster$1, recoverSnapshot as recoverSnapshot$1, recoverSnapshotFromTx as recoverSnapshotFromTx$1, redeem as redeem$1, redeemAndWait as redeemAndWait$1, repay as repay$1, repayAndWait as repayAndWait$1, resolveTokenIndex as resolveTokenIndex$1, rollPosition as rollPosition$1, rollPositionAndWait as rollPositionAndWait$1, saveCheckpoint as saveCheckpoint$1, selectDispatchForAccount as selectDispatchForAccount$1, settleAccumulatedPremia as settleAccumulatedPremia$1, settleAccumulatedPremiaAndWait as settleAccumulatedPremiaAndWait$1, simulateOpenPosition as simulateOpenPosition$1, simulateWithTokenFlow, smartRepay as smartRepay$1, smartRepayAndWait as smartRepayAndWait$1, speedUpTransaction as speedUpTransaction$1, supply as supply$1, supplyAndWait as supplyAndWait$1, swapExactIn as swapExactIn$1, swapExactInAndWait as swapExactInAndWait$1, swapExactOut as swapExactOut$1, swapExactOutAndWait as swapExactOutAndWait$1, syncPositions as syncPositions$1, unsupply as unsupply$1, unsupplyAndWait as unsupplyAndWait$1, unwrapWeth as unwrapWeth$1, unwrapWethAndWait as unwrapWethAndWait$1, unwrapXstock as unwrapXstock$1, unwrapXstockAndWait as unwrapXstockAndWait$1, validateBatch as validateBatch$1, validatePoolId as validatePoolId$1, verifyBlockContinuity as verifyBlockContinuity$1, wethWrapAbi as wethWrapAbi$1, withdraw as withdraw$1, withdrawAndWait as withdrawAndWait$1, withdrawWithPositions as withdrawWithPositions$1, withdrawWithPositionsAndWait as withdrawWithPositionsAndWait$1, wrapEth as wrapEth$1, wrapEthAndWait as wrapEthAndWait$1, wrapXstock as wrapXstock$1, wrapXstockAndWait as wrapXstockAndWait$1, xstockWrapperAbi as xstockWrapperAbi$1 };
-//# sourceMappingURL=writes-AupZCK4M.js.map
+export { addLegToTokenId as addLegToTokenId$1, approve as approve$1, approveAndWait as approveAndWait$1, approvePool as approvePool$1, borrow as borrow$1, borrowAndWait as borrowAndWait$1, buildBatchDispatchArgs as buildBatchDispatchArgs$1, buildCreditSwapCall as buildCreditSwapCall$1, buildOpenPositionCalldata as buildOpenPositionCalldata$1, buildUniqueCredit as buildUniqueCredit$1, buildUniqueLoan as buildUniqueLoan$1, buildUniqueWidthZeroLeg as buildUniqueWidthZeroLeg$1, calculateResyncBlock as calculateResyncBlock$1, cancelTransaction as cancelTransaction$1, checkApproval as checkApproval$1, clearCheckpoint as clearCheckpoint$1, closePosition as closePosition$1, closePositionAndWait as closePositionAndWait$1, countLegs as countLegs$1, createNonceManager as createNonceManager$1, createTokenIdBuilder as createTokenIdBuilder$1, decodeAllLegs as decodeAllLegs$1, decodeLeg as decodeLeg$1, decodePoolId as decodePoolId$1, decodeTickSpacing as decodeTickSpacing$2, decodeTokenId as decodeTokenId$1, decodeVegoid as decodeVegoid$1, deployNewPool as deployNewPool$1, deployNewPoolAndWait as deployNewPoolAndWait$1, deposit as deposit$1, depositAndWait as depositAndWait$1, detectReorg as detectReorg$1, dispatch as dispatch$1, dispatchAndWait as dispatchAndWait$1, encodeLeg as encodeLeg$1, encodePoolId as encodePoolId$1, encodeV4PoolId as encodeV4PoolId$1, executeBatchDispatch as executeBatchDispatch$1, executeBatchDispatchAndWait as executeBatchDispatchAndWait$1, forceExercise as forceExercise$1, forceExerciseAndWait as forceExerciseAndWait$1, getAssetIndex as getAssetIndex$1, getPoolDeploymentBlock as getPoolDeploymentBlock$1, getPoolTokensForSimulation, hasLoanOrCredit as hasLoanOrCredit$1, hasLongLeg as hasLongLeg$1, isCredit as isCredit$1, isCreditLeg as isCreditLeg$1, isInputListFailError as isInputListFailError$1, isLoan as isLoan$1, isLoanLeg as isLoanLeg$1, isShortOnly as isShortOnly$1, isSpread as isSpread$1, liquidate as liquidate$1, liquidateAndWait as liquidateAndWait$1, loadCheckpoint as loadCheckpoint$1, mint as mint$1, mintAndWait as mintAndWait$1, openPosition as openPosition$1, openPositionAndWait as openPositionAndWait$1, pokeOracle as pokeOracle$1, pokeOracleAndWait as pokeOracleAndWait$1, previewBorrow as previewBorrow$1, previewUnwrap as previewUnwrap$1, previewWrap as previewWrap$1, publicBroadcaster as publicBroadcaster$1, reconstructFromEvents as reconstructFromEvents$1, redeem as redeem$1, redeemAndWait as redeemAndWait$1, repay as repay$1, repayAndWait as repayAndWait$1, resolveTokenIndex as resolveTokenIndex$1, rollPosition as rollPosition$1, rollPositionAndWait as rollPositionAndWait$1, saveCheckpoint as saveCheckpoint$1, settleAccumulatedPremia as settleAccumulatedPremia$1, settleAccumulatedPremiaAndWait as settleAccumulatedPremiaAndWait$1, simulateOpenPosition as simulateOpenPosition$1, simulateWithTokenFlow as simulateWithTokenFlow$1, smartRepay as smartRepay$1, smartRepayAndWait as smartRepayAndWait$1, speedUpTransaction as speedUpTransaction$1, supply as supply$1, supplyAndWait as supplyAndWait$1, swapExactIn as swapExactIn$1, swapExactInAndWait as swapExactInAndWait$1, swapExactOut as swapExactOut$1, swapExactOutAndWait as swapExactOutAndWait$1, syncPositions as syncPositions$1, unsupply as unsupply$1, unsupplyAndWait as unsupplyAndWait$1, unwrapWeth as unwrapWeth$1, unwrapWethAndWait as unwrapWethAndWait$1, unwrapXstock as unwrapXstock$1, unwrapXstockAndWait as unwrapXstockAndWait$1, validateBatch as validateBatch$1, validatePoolId as validatePoolId$1, verifyBlockContinuity as verifyBlockContinuity$1, wethWrapAbi as wethWrapAbi$1, withdraw as withdraw$1, withdrawAndWait as withdrawAndWait$1, withdrawWithPositions as withdrawWithPositions$1, withdrawWithPositionsAndWait as withdrawWithPositionsAndWait$1, wrapEth as wrapEth$1, wrapEthAndWait as wrapEthAndWait$1, wrapXstock as wrapXstock$1, wrapXstockAndWait as wrapXstockAndWait$1, xstockWrapperAbi as xstockWrapperAbi$1 };
+//# sourceMappingURL=writes-D3bj1wth.js.map