@panoptic-eng/sdk 1.0.60 → 1.0.61

package/dist/cow/index.js

@@ -1,4 +1,4 @@
-import { decodeEventLog, encodeFunctionData, erc20Abi, getAbiItem, getAddress, keccak256, maxUint256, parseAbi, stringToHex, toFunctionSelector, zeroAddress } from "viem";
+import { BaseError, decodeErrorResult, decodeEventLog, encodeFunctionData, erc20Abi, getAbiItem, getAddress, keccak256, maxUint256, parseAbi, stringToHex, toFunctionSelector, zeroAddress } from "viem";
 
 //#region src/cow/addresses.ts
 /** GPv2Settlement — EIP-712 verifying contract for signed orders. */
@@ -3099,576 +3099,790 @@ const riskEngineAbi = [
 ];
 
 //#endregion
-//#region src/panoptic/v2/writes/utils.ts
+//#region src/panoptic/v2/errors/base.ts
 /**
-* Decode PositionBalance packed data.
+* Base error class for the Panoptic v2 SDK.
+* @module v2/errors/base
+*/
+/**
+* Base error class for all Panoptic SDK errors.
+* All errors thrown by the SDK extend this class.
 *
-* Layout (from LSB to MSB):
-* - positionSize:     bits 0-127   (uint128)
-* - poolUtilization0: bits 128-143 (uint16)
-* - poolUtilization1: bits 144-159 (uint16)
-* - tickAtMint:       bits 160-183 (int24)
-* - timestampAtMint:  bits 184-215 (uint32)
-* - blockAtMint:      bits 216-254 (uint39)
-* - swapAtMint:       bit 255      (bool)
+* @example
+* ```typescript
+* try {
+*   await openPosition(config, params)
+* } catch (error) {
+*   if (error instanceof PanopticError) {
+*     console.log('Panoptic error:', error.name, error.message)
+*     console.log('Original cause:', error.cause)
+*   }
+* }
+* ```
 */
-function decodePositionBalance(balanceData) {
-	const positionSize = balanceData & (1n << 128n) - 1n;
-	const poolUtilization0 = balanceData >> 128n & 0xffffn;
-	const poolUtilization1 = balanceData >> 144n & 0xffffn;
-	let tickAtMint = balanceData >> 160n & 0xffffffn;
-	if (tickAtMint > 0x7fffffn) tickAtMint = tickAtMint - 0x1000000n;
-	const timestampAtMint = balanceData >> 184n & 0xffffffffn;
-	const blockAtMint = balanceData >> 216n & (1n << 39n) - 1n;
-	const swapAtMint = balanceData >> 255n === 1n;
-	return {
-		positionSize,
-		poolUtilization0,
-		poolUtilization1,
-		tickAtMint,
-		timestampAtMint,
-		blockAtMint,
-		swapAtMint
-	};
-}
+var PanopticError = class extends Error {
+	name = "PanopticError";
+	/** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
+	errorName;
+	/**
+	* Creates a new PanopticError.
+	*
+	* @param message - Human-readable error message
+	* @param cause - Optional underlying error that caused this error
+	*/
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+
+//#endregion
+//#region src/panoptic/v2/errors/contract.ts
 /**
-* Decode LeftRightSigned packed value.
+* The account is not solvent enough to perform the desired action.
+* @see Errors.sol:9
 */
-function decodeLeftRightSigned(value) {
-	let right = value & (1n << 128n) - 1n;
-	let left = value >> 128n;
-	if (right >= 1n << 127n) right = right - (1n << 128n);
-	if (left >= 1n << 127n) left = left - (1n << 128n);
-	return {
-		right,
-		left
-	};
-}
+var AccountInsolventError = class extends PanopticError {
+	name = "AccountInsolventError";
+	constructor(solvent, numberOfTicks, cause) {
+		super(`Account insolvent: solvent=${solvent}, numberOfTicks=${numberOfTicks}`, cause);
+		this.solvent = solvent;
+		this.numberOfTicks = numberOfTicks;
+	}
+};
 /**
-* Parse Panoptic events from transaction logs.
-*
-* @param logs - The transaction logs
-* @returns Parsed Panoptic events
+* Position is still solvent and cannot be liquidated.
+* @see Errors.sol:84
 */
-function parsePanopticEvents(logs) {
-	const events = [];
-	for (const log of logs) {
-		const baseEvent = {
-			blockNumber: log.blockNumber ?? 0n,
-			blockHash: log.blockHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
-			transactionHash: log.transactionHash ?? "0x",
-			logIndex: BigInt(log.logIndex ?? 0)
-		};
-		try {
-			const poolEvent = decodeEventLog({
-				abi: panopticPoolV2Abi,
-				data: log.data,
-				topics: log.topics
-			});
-			if (poolEvent.eventName === "OptionMinted") {
-				const args = poolEvent.args;
-				const balance = decodePositionBalance(args.balanceData);
-				events.push({
-					type: "OptionMinted",
-					...baseEvent,
-					recipient: args.recipient,
-					tokenId: args.tokenId,
-					positionSize: balance.positionSize,
-					poolUtilization0: balance.poolUtilization0,
-					poolUtilization1: balance.poolUtilization1,
-					tickAtMint: balance.tickAtMint,
-					timestampAtMint: balance.timestampAtMint,
-					blockAtMint: balance.blockAtMint,
-					swapAtMint: balance.swapAtMint
-				});
-			} else if (poolEvent.eventName === "OptionBurnt") {
-				const args = poolEvent.args;
-				events.push({
-					type: "OptionBurnt",
-					...baseEvent,
-					recipient: args.recipient,
-					tokenId: args.tokenId,
-					positionSize: args.positionSize,
-					premiaByLeg: [
-						args.premiaByLeg[0] ?? 0n,
-						args.premiaByLeg[1] ?? 0n,
-						args.premiaByLeg[2] ?? 0n,
-						args.premiaByLeg[3] ?? 0n
-					]
-				});
-			} else if (poolEvent.eventName === "AccountLiquidated") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.bonusAmounts);
-				events.push({
-					type: "AccountLiquidated",
-					...baseEvent,
-					liquidator: args.liquidator,
-					liquidatee: args.liquidatee,
-					bonusAmount0: right,
-					bonusAmount1: left
-				});
-			} else if (poolEvent.eventName === "ForcedExercised") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.exerciseFee);
-				events.push({
-					type: "ForcedExercised",
-					...baseEvent,
-					exercisor: args.exercisor,
-					user: args.user,
-					tokenId: args.tokenId,
-					exerciseFee0: right,
-					exerciseFee1: left
-				});
-			} else if (poolEvent.eventName === "PremiumSettled") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.settledAmounts);
-				events.push({
-					type: "PremiumSettled",
-					...baseEvent,
-					user: args.user,
-					tokenId: args.tokenId,
-					legIndex: args.legIndex,
-					settledAmount0: right,
-					settledAmount1: left
-				});
-			}
-		} catch {
-			try {
-				const collateralEvent = decodeEventLog({
-					abi: collateralTrackerV2Abi,
-					data: log.data,
-					topics: log.topics
-				});
-				if (collateralEvent.eventName === "Deposit") {
-					const args = collateralEvent.args;
-					events.push({
-						type: "Deposit",
-						...baseEvent,
-						sender: args.sender,
-						owner: args.owner,
-						assets: args.assets,
-						shares: args.shares
-					});
-				} else if (collateralEvent.eventName === "Withdraw") {
-					const args = collateralEvent.args;
-					events.push({
-						type: "Withdraw",
-						...baseEvent,
-						sender: args.sender,
-						receiver: args.receiver,
-						owner: args.owner,
-						assets: args.assets,
-						shares: args.shares
-					});
-				}
-			} catch {}
-		}
+var NotMarginCalledError = class extends PanopticError {
+	name = "NotMarginCalledError";
+	constructor(cause) {
+		super("Position is still solvent and cannot be liquidated", cause);
 	}
-	return events;
-}
+};
 /**
-* Create a TxResult from a transaction hash.
-*
-* @param client - The public client
-* @param hash - The transaction hash
-* @returns TxResult with wait function
+* The user does not own enough assets to open/close a position.
+* @see Errors.sol:78
 */
-function createTxResult(client, hash) {
-	return {
-		hash,
-		wait: async (confirmations) => {
-			const receipt = await client.waitForTransactionReceipt({
-				hash,
-				confirmations: confirmations !== void 0 ? Number(confirmations) : void 0
-			});
-			const events = parsePanopticEvents(receipt.logs);
-			return {
-				hash: receipt.transactionHash,
-				blockNumber: receipt.blockNumber,
-				blockHash: receipt.blockHash,
-				gasUsed: receipt.gasUsed,
-				status: receipt.status === "success" ? "success" : "reverted",
-				events
-			};
-		}
-	};
-}
+var NotEnoughTokensError = class extends PanopticError {
+	name = "NotEnoughTokensError";
+	constructor(tokenAddress, assetsRequested, assetBalance, cause) {
+		super(`Not enough tokens: requested=${assetsRequested}, balance=${assetBalance}, token=${tokenAddress}`, cause);
+		this.tokenAddress = tokenAddress;
+		this.assetsRequested = assetsRequested;
+		this.assetBalance = assetBalance;
+	}
+};
 /**
-* Submit a write operation, supporting both direct wallet submission
-* and custom broadcaster paths with gas overrides.
-*
-* Normal path (no broadcaster): calls walletClient.writeContract() with gas overrides.
-* Broadcaster path: prepareTransactionRequest → apply overrides → signTransaction → broadcast.
-*
-* @param params - Submit write parameters
-* @returns TxResult
+* There is not enough available liquidity in the chunk for a long leg.
+* @see Errors.sol:75
 */
-async function submitWrite(params) {
-	const { client, walletClient, account, address, abi, functionName, args, value, txOverrides } = params;
-	const broadcaster = txOverrides?.broadcaster;
-	if (broadcaster) {
-		const data = encodeFunctionData({
-			abi,
-			functionName,
-			args
-		});
-		const broadcastAccount = walletClient.account ?? account;
-		const request = await walletClient.prepareTransactionRequest({
-			account: broadcastAccount,
-			to: address,
-			chain: walletClient.chain,
-			data,
-			...value !== void 0 && { value },
-			...txOverrides?.maxFeePerGas !== void 0 && { maxFeePerGas: txOverrides.maxFeePerGas },
-			...txOverrides?.maxPriorityFeePerGas !== void 0 && { maxPriorityFeePerGas: txOverrides.maxPriorityFeePerGas },
-			...txOverrides?.gas !== void 0 && { gas: txOverrides.gas },
-			...txOverrides?.nonce !== void 0 && { nonce: Number(txOverrides.nonce) }
-		});
-		const signedTx = await walletClient.signTransaction({
-			...request,
-			account: broadcastAccount
-		});
-		const hash$1 = await broadcaster.broadcast(signedTx);
-		return createTxResult(client, hash$1);
+var NotEnoughLiquidityInChunkError = class extends PanopticError {
+	name = "NotEnoughLiquidityInChunkError";
+	constructor(cause) {
+		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
 	}
-	const gasOverrides = {};
-	if (txOverrides?.maxFeePerGas !== void 0) gasOverrides.maxFeePerGas = txOverrides.maxFeePerGas;
-	if (txOverrides?.maxPriorityFeePerGas !== void 0) gasOverrides.maxPriorityFeePerGas = txOverrides.maxPriorityFeePerGas;
-	if (txOverrides?.nonce !== void 0) gasOverrides.nonce = Number(txOverrides.nonce);
-	const resolvedAccount = walletClient.account ?? account;
-	if (txOverrides?.gas !== void 0) gasOverrides.gas = txOverrides.gas;
-	else {
-		const estimated = await client.estimateContractGas({
-			address,
-			abi,
-			functionName,
-			args,
-			account: resolvedAccount,
-			...value !== void 0 && { value }
-		});
-		gasOverrides.gas = estimated * 120n / 100n;
+};
+/**
+* There is not enough available liquidity to fulfill a credit.
+* @see Errors.sol:47
+*/
+var InsufficientCreditLiquidityError = class extends PanopticError {
+	name = "InsufficientCreditLiquidityError";
+	constructor(cause) {
+		super("Insufficient credit liquidity available in the PanopticPool", cause);
 	}
-	const hash = await walletClient.writeContract({
-		address,
-		abi,
-		functionName,
-		args,
-		account: resolvedAccount,
-		chain: walletClient.chain,
-		...value !== void 0 && { value },
-		...gasOverrides
-	});
-	return createTxResult(client, hash);
-}
-
-//#endregion
-//#region src/panoptic/v2/errors/base.ts
+};
 /**
-* Base error class for the Panoptic v2 SDK.
-* @module v2/errors/base
+* The amount deposited is larger than the maximum permitted.
+* @see Errors.sol:25
 */
+var DepositTooLargeError = class extends PanopticError {
+	name = "DepositTooLargeError";
+	constructor(cause) {
+		super("Deposit amount exceeds maximum permitted", cause);
+	}
+};
 /**
-* Base error class for all Panoptic SDK errors.
-* All errors thrown by the SDK extend this class.
-*
-* @example
-* ```typescript
-* try {
-*   await openPosition(config, params)
-* } catch (error) {
-*   if (error instanceof PanopticError) {
-*     console.log('Panoptic error:', error.name, error.message)
-*     console.log('Original cause:', error.cause)
-*   }
-* }
-* ```
+* Attempted to withdraw/redeem less than a single asset.
+* @see Errors.sol:16
 */
-var PanopticError = class extends Error {
-	name = "PanopticError";
-	/** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
-	errorName;
+var BelowMinimumRedemptionError = class extends PanopticError {
+	name = "BelowMinimumRedemptionError";
+	constructor(cause) {
+		super("Redemption amount below minimum threshold", cause);
+	}
+};
+/**
+* Attempted to withdraw/redeem more than available.
+* @see Errors.sol:35
+*/
+var ExceedsMaximumRedemptionError = class extends PanopticError {
+	name = "ExceedsMaximumRedemptionError";
+	constructor(cause) {
+		super("Redemption exceeds maximum available (liquidity, shares, or open positions)", cause);
+	}
+};
+/**
+* Mints/burns of a position returns no collateral requirement.
+* @see Errors.sol:141
+*/
+var ZeroCollateralRequirementError = class extends PanopticError {
+	name = "ZeroCollateralRequirementError";
+	constructor(cause) {
+		super("Position mint/burn returned zero collateral requirement", cause);
+	}
+};
+/**
+* The TokenId provided is malformed or invalid.
+* @see Errors.sol:54
+*/
+var InvalidTokenIdParameterError = class extends PanopticError {
+	name = "InvalidTokenIdParameterError";
 	/**
-	* Creates a new PanopticError.
-	*
-	* @param message - Human-readable error message
-	* @param cause - Optional underlying error that caused this error
+	* Parameter type meanings:
+	* 0=poolId, 1=ratio, 2=tokenType, 3=riskPartner, 4=strike, 5=width, 6=duplicateChunk
 	*/
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-		Object.setPrototypeOf(this, new.target.prototype);
+	constructor(parameterType, cause) {
+		const paramNames = [
+			"poolId",
+			"ratio",
+			"tokenType",
+			"riskPartner",
+			"strike",
+			"width",
+			"duplicateChunk"
+		];
+		const paramName = paramNames[Number(parameterType)] ?? `unknown(${parameterType})`;
+		super(`Invalid TokenId parameter: ${paramName}`, cause);
+		this.parameterType = parameterType;
 	}
 };
-
-//#endregion
-//#region src/panoptic/v2/errors/errorsAbi.ts
 /**
-* Custom error ABI definitions for Panoptic v2 contracts.
-*
-* Contains all custom errors from Errors.sol with their signatures.
-* Used for decoding contract revert data.
-*
-* Selectors sourced from `forge selectors list` output.
-*
-* @module v2/errors/errorsAbi
+* Position is not owned by the user and has positionSize=0.
+* @see Errors.sol:96
 */
+var PositionNotOwnedError = class extends PanopticError {
+	name = "PositionNotOwnedError";
+	constructor(cause) {
+		super("Position is not owned by the user", cause);
+	}
+};
 /**
-* All custom errors from Panoptic Errors.sol
-*
-* Selector computation: keccak256(errorSignature)[:4]
+* The maximum token deltas for a position exceed limits.
+* @see Errors.sol:99
 */
-const panopticErrorsAbi = [
-	{
-		type: "error",
-		name: "AccountInsolvent",
-		inputs: [{
-			name: "solvent",
-			type: "uint256"
-		}, {
-			name: "numberOfTicks",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "error",
-		name: "AlreadyInitialized",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "BelowMinimumRedemption",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "CastingError",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "ChunkHasZeroLiquidity",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "CreateFail",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "DepositTooLarge",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "DuplicateTokenId",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "EffectiveLiquidityAboveThreshold",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "ExceedsMaximumRedemption",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InputListFail",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InsufficientCreditLiquidity",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InvalidBuilderCode",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InvalidTick",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InvalidTickBound",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "InvalidTokenIdParameter",
-		inputs: [{
-			name: "parameterType",
-			type: "uint256"
-		}]
-	},
-	{
-		type: "error",
-		name: "InvalidUniswapCallback",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "LengthMismatch",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "LiquidityTooHigh",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NetLiquidityZero",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NoLegsExercisable",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NotALongLeg",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NotBuilder",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NotEnoughLiquidityInChunk",
-		inputs: []
-	},
-	{
-		type: "error",
-		name: "NotEnoughTokens",
-		inputs: [
-			{
-				name: "tokenAddress",
-				type: "address"
-			},
-			{
-				name: "assetsRequested",
-				type: "uint256"
-			},
-			{
-				name: "assetBalance",
-				type: "uint256"
-			}
-		]
-	},
-	{
+var PositionTooLargeError = class extends PanopticError {
+	name = "PositionTooLargeError";
+	constructor(cause) {
+		super("Position size exceeds maximum allowed token deltas", cause);
+	}
+};
+/**
+* User has open positions, so they cannot transfer collateral shares.
+* @see Errors.sol:93
+*/
+var PositionCountNotZeroError = class extends PanopticError {
+	name = "PositionCountNotZeroError";
+	constructor(cause) {
+		super("Cannot transfer collateral shares while positions are open", cause);
+	}
+};
+/**
+* The list of provided TokenIds has a duplicate entry.
+* @see Errors.sol:28
+*/
+var DuplicateTokenIdError = class extends PanopticError {
+	name = "DuplicateTokenIdError";
+	constructor(cause) {
+		super("Duplicate TokenId in provided list", cause);
+	}
+};
+/**
+* The supplied tokenId has no valid legs.
+* @see Errors.sol:144
+*/
+var TokenIdHasZeroLegsError = class extends PanopticError {
+	name = "TokenIdHasZeroLegsError";
+	constructor(cause) {
+		super("TokenId has no valid legs", cause);
+	}
+};
+/**
+* Position would exceed maximum legs open for account.
+* @see Errors.sol:112
+*/
+var TooManyLegsOpenError = class extends PanopticError {
+	name = "TooManyLegsOpenError";
+	constructor(cause) {
+		super("Position would exceed maximum allowed legs open", cause);
+	}
+};
+/**
+* The provided list of option positions is incorrect or invalid.
+* @see Errors.sol:38
+*/
+var InputListFailError = class extends PanopticError {
+	name = "InputListFailError";
+	constructor(cause) {
+		super("Invalid position list provided", cause);
+	}
+};
+/**
+* Tick is not between MIN_TICK and MAX_TICK.
+* @see Errors.sol:41
+*/
+var InvalidTickError = class extends PanopticError {
+	name = "InvalidTickError";
+	constructor(cause) {
+		super("Tick is outside valid range (MIN_TICK to MAX_TICK)", cause);
+	}
+};
+/**
+* The tick range is invalid (not initializable or exceeds bounds).
+* @see Errors.sol:120
+*/
+var InvalidTickBoundError = class extends PanopticError {
+	name = "InvalidTickBoundError";
+	constructor(cause) {
+		super("Tick range is invalid (not initializable multiples of tickSpacing or exceeds bounds)", cause);
+	}
+};
+/**
+* The current tick has fallen outside the slippage range.
+* @see Errors.sol:102
+*/
+var PriceBoundFailError = class extends PanopticError {
+	name = "PriceBoundFailError";
+	constructor(currentTick, cause) {
+		super(`Price moved outside slippage bounds (currentTick=${currentTick})`, cause);
+		this.currentTick = currentTick;
+	}
+};
+/**
+* The price impact of the trade is too large.
+* @see Errors.sol:105
+*/
+var PriceImpactTooLargeError = class extends PanopticError {
+	name = "PriceImpactTooLargeError";
+	constructor(cause) {
+		super("Price impact of trade exceeds maximum allowed", cause);
+	}
+};
+/**
+* Mints/burns of zero-liquidity chunks are not supported.
+* @see Errors.sol:19
+*/
+var ChunkHasZeroLiquidityError = class extends PanopticError {
+	name = "ChunkHasZeroLiquidityError";
+	constructor(cause) {
+		super("Cannot mint/burn chunk with zero liquidity", cause);
+	}
+};
+/**
+* Liquidity in a chunk is above 2^128.
+* @see Errors.sol:44
+*/
+var LiquidityTooHighError = class extends PanopticError {
+	name = "LiquidityTooHighError";
+	constructor(cause) {
+		super("Liquidity exceeds maximum (2^128)", cause);
+	}
+};
+/**
+* Net liquidity is zero due to small positions.
+* @see Errors.sol:63
+*/
+var NetLiquidityZeroError = class extends PanopticError {
+	name = "NetLiquidityZeroError";
+	constructor(cause) {
+		super("Net liquidity is zero, cannot compute liquidity spread", cause);
+	}
+};
+/**
+* Effective liquidity above threshold during long mint or short burn.
+* @see Errors.sol:32
+*/
+var EffectiveLiquidityAboveThresholdError = class extends PanopticError {
+	name = "EffectiveLiquidityAboveThresholdError";
+	constructor(cause) {
+		super("Effective liquidity above spread threshold", cause);
+	}
+};
+/**
+* An oracle price is too far from another or the current tick.
+* @see Errors.sol:109
+*/
+var StaleOracleError = class extends PanopticError {
+	name = "StaleOracleError";
+	constructor(cause) {
+		super("Oracle price deviation too high (potential manipulation safeguard)", cause);
+	}
+};
+/**
+* None of the legs in a position are force-exercisable.
+* @see Errors.sol:66
+*/
+var NoLegsExercisableError = class extends PanopticError {
+	name = "NoLegsExercisableError";
+	constructor(cause) {
+		super("No legs are force-exercisable (all are short or ATM long)", cause);
+	}
+};
+/**
+* The leg is not long, so premium cannot be settled.
+* @see Errors.sol:69
+*/
+var NotALongLegError = class extends PanopticError {
+	name = "NotALongLegError";
+	constructor(cause) {
+		super("Cannot settle premium for non-long leg", cause);
+	}
+};
+/**
+* The Uniswap Pool has not been created.
+* @see Errors.sol:90
+*/
+var PoolNotInitializedError = class extends PanopticError {
+	name = "PoolNotInitializedError";
+	constructor(cause) {
+		super("Uniswap pool not initialized", cause);
+	}
+};
+/**
+* Smart contract has already been initialized.
+* @see Errors.sol:22
+*/
+var AlreadyInitializedError = class extends PanopticError {
+	name = "AlreadyInitializedError";
+	constructor(cause) {
+		super("Contract already initialized", cause);
+	}
+};
+/**
+* The supplied poolId does not match the poolId for that Uniswap Pool.
+* @see Errors.sol:132
+*/
+var WrongPoolIdError = class extends PanopticError {
+	name = "WrongPoolIdError";
+	constructor(cause) {
+		super("Pool ID mismatch", cause);
+	}
+};
+/**
+* The poolId's don't match (SFPM).
+* @see Errors.sol:135
+*/
+var WrongUniswapPoolError = class extends PanopticError {
+	name = "WrongUniswapPoolError";
+	constructor(cause) {
+		super("Uniswap pool mismatch", cause);
+	}
+};
+/**
+* The caller is not the Panoptic Pool.
+* @see Errors.sol:87
+*/
+var NotPanopticPoolError = class extends PanopticError {
+	name = "NotPanopticPoolError";
+	constructor(cause) {
+		super("Caller is not the Panoptic Pool", cause);
+	}
+};
+/**
+* Can only be called by the guardian.
+* @see Errors.sol:81
+*/
+var NotGuardianError = class extends PanopticError {
+	name = "NotGuardianError";
+	constructor(cause) {
+		super("Caller is not the guardian", cause);
+	}
+};
+/**
+* Can only be called by the Builder.
+* @see Errors.sol:72
+*/
+var NotBuilderError = class extends PanopticError {
+	name = "NotBuilderError";
+	constructor(cause) {
+		super("Caller is not the builder", cause);
+	}
+};
+/**
+* Invalid builder code.
+* @see Errors.sol:50
+*/
+var InvalidBuilderCodeError = class extends PanopticError {
+	name = "InvalidBuilderCodeError";
+	constructor(cause) {
+		super("Invalid builder code", cause);
+	}
+};
+/**
+* Mint or swap callback from invalid address.
+* @see Errors.sol:57
+*/
+var InvalidUniswapCallbackError = class extends PanopticError {
+	name = "InvalidUniswapCallbackError";
+	constructor(cause) {
+		super("Invalid Uniswap callback (address mismatch)", cause);
+	}
+};
+/**
+* Unlock callback from non-canonical pool manager.
+* @see Errors.sol:123
+*/
+var UnauthorizedUniswapCallbackError = class extends PanopticError {
+	name = "UnauthorizedUniswapCallbackError";
+	constructor(cause) {
+		super("Unauthorized Uniswap V4 callback", cause);
+	}
+};
+/**
+* ERC20 or SFPM (ERC1155) token transfer did not complete successfully.
+* @see Errors.sol:115
+*/
+var TransferFailedError = class extends PanopticError {
+	name = "TransferFailedError";
+	constructor(token, from, amount, balance, cause) {
+		super(`Transfer failed: token=${token}, from=${from}, amount=${amount}, balance=${balance}`, cause);
+		this.token = token;
+		this.from = from;
+		this.amount = amount;
+		this.balance = balance;
+	}
+};
+/**
+* Casting error (e.g., uint128(uint256(a)) fails).
+* @see Errors.sol:13
+*/
+var CastingError = class extends PanopticError {
+	name = "CastingError";
+	constructor(cause) {
+		super("Numeric casting overflow", cause);
+	}
+};
+/**
+* Underflow or overflow in library operation.
+* @see Errors.sol:126
+*/
+var UnderOverFlowError = class extends PanopticError {
+	name = "UnderOverFlowError";
+	constructor(cause) {
+		super("Arithmetic underflow or overflow", cause);
+	}
+};
+/**
+* Reentrancy check triggered.
+* @see Errors.sol:129
+*/
+var ReentrancyError = class extends PanopticError {
+	name = "ReentrancyError";
+	constructor(cause) {
+		super("Reentrancy detected", cause);
+	}
+};
+/**
+* Pool deployment via CREATE2 failed.
+*/
+var CreateFailError = class extends PanopticError {
+	name = "CreateFailError";
+	constructor(cause) {
+		super("Pool deployment failed (CREATE2)", cause);
+	}
+};
+/**
+* Zero address was supplied as a parameter.
+* @see Errors.sol:138
+*/
+var ZeroAddressError = class extends PanopticError {
+	name = "ZeroAddressError";
+	constructor(cause) {
+		super("Zero address supplied", cause);
+	}
+};
+/**
+* Length mismatch between positionIdList and positionBalanceArray.
+* @see Errors.sol:60
+*/
+var LengthMismatchError = class extends PanopticError {
+	name = "LengthMismatchError";
+	constructor(cause) {
+		super("Array length mismatch", cause);
+	}
+};
+
+//#endregion
+//#region src/panoptic/v2/errors/errorsAbi.ts
+/**
+* Custom error ABI definitions for Panoptic v2 contracts.
+*
+* Contains all custom errors from Errors.sol with their signatures.
+* Used for decoding contract revert data.
+*
+* Selectors sourced from `forge selectors list` output.
+*
+* @module v2/errors/errorsAbi
+*/
+/**
+* All custom errors from Panoptic Errors.sol
+*
+* Selector computation: keccak256(errorSignature)[:4]
+*/
+const panopticErrorsAbi = [
+	{
 		type: "error",
-		name: "NotGuardian",
-		inputs: []
+		name: "AccountInsolvent",
+		inputs: [{
+			name: "solvent",
+			type: "uint256"
+		}, {
+			name: "numberOfTicks",
+			type: "uint256"
+		}]
 	},
 	{
 		type: "error",
-		name: "NotMarginCalled",
+		name: "AlreadyInitialized",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "NotPanopticPool",
+		name: "BelowMinimumRedemption",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "PoolNotInitialized",
+		name: "CastingError",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "PositionCountNotZero",
+		name: "ChunkHasZeroLiquidity",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "PositionNotOwned",
+		name: "CreateFail",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "PositionTooLarge",
+		name: "DepositTooLarge",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "PriceBoundFail",
-		inputs: [{
-			name: "currentTick",
-			type: "int24"
-		}]
+		name: "DuplicateTokenId",
+		inputs: []
 	},
 	{
 		type: "error",
-		name: "PriceImpactTooLarge",
+		name: "EffectiveLiquidityAboveThreshold",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "Reentrancy",
+		name: "ExceedsMaximumRedemption",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "StaleOracle",
+		name: "InputListFail",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "TokenIdHasZeroLegs",
+		name: "InsufficientCreditLiquidity",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "TooManyLegsOpen",
+		name: "InvalidBuilderCode",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "TransferFailed",
-		inputs: [
-			{
-				name: "token",
-				type: "address"
-			},
-			{
-				name: "from",
-				type: "address"
-			},
-			{
-				name: "amount",
-				type: "uint256"
-			},
-			{
-				name: "balance",
-				type: "uint256"
-			}
-		]
+		name: "InvalidTick",
+		inputs: []
 	},
 	{
 		type: "error",
-		name: "UnauthorizedUniswapCallback",
+		name: "InvalidTickBound",
 		inputs: []
 	},
 	{
 		type: "error",
-		name: "UnderOverFlow",
-		inputs: []
+		name: "InvalidTokenIdParameter",
+		inputs: [{
+			name: "parameterType",
+			type: "uint256"
+		}]
 	},
 	{
 		type: "error",
-		name: "WrongPoolId",
+		name: "InvalidUniswapCallback",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "LengthMismatch",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "LiquidityTooHigh",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NetLiquidityZero",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NoLegsExercisable",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotALongLeg",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotBuilder",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotEnoughLiquidityInChunk",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotEnoughTokens",
+		inputs: [
+			{
+				name: "tokenAddress",
+				type: "address"
+			},
+			{
+				name: "assetsRequested",
+				type: "uint256"
+			},
+			{
+				name: "assetBalance",
+				type: "uint256"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "NotGuardian",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotMarginCalled",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NotPanopticPool",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "PoolNotInitialized",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "PositionCountNotZero",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "PositionNotOwned",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "PositionTooLarge",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "PriceBoundFail",
+		inputs: [{
+			name: "currentTick",
+			type: "int24"
+		}]
+	},
+	{
+		type: "error",
+		name: "PriceImpactTooLarge",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "Reentrancy",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "StaleOracle",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "TokenIdHasZeroLegs",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "TooManyLegsOpen",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "TransferFailed",
+		inputs: [
+			{
+				name: "token",
+				type: "address"
+			},
+			{
+				name: "from",
+				type: "address"
+			},
+			{
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				name: "balance",
+				type: "uint256"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "UnauthorizedUniswapCallback",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "UnderOverFlow",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "WrongPoolId",
 		inputs: []
 	},
 	{
@@ -3700,6 +3914,515 @@ const combinedAbi = [
 	...riskEngineAbi,
 	...panopticErrorsAbi
 ];
+/**
+* Map of error names to error constructors.
+*/
+const errorConstructors = {
+	AccountInsolvent: (args, cause) => new AccountInsolventError(args[0], args[1], cause),
+	NotMarginCalled: (_args, cause) => new NotMarginCalledError(cause),
+	CreateFail: (_args, cause) => new CreateFailError(cause),
+	NotEnoughTokens: (args, cause) => new NotEnoughTokensError(args[0], args[1], args[2], cause),
+	NotEnoughLiquidityInChunk: (_args, cause) => new NotEnoughLiquidityInChunkError(cause),
+	InsufficientCreditLiquidity: (_args, cause) => new InsufficientCreditLiquidityError(cause),
+	DepositTooLarge: (_args, cause) => new DepositTooLargeError(cause),
+	BelowMinimumRedemption: (_args, cause) => new BelowMinimumRedemptionError(cause),
+	ExceedsMaximumRedemption: (_args, cause) => new ExceedsMaximumRedemptionError(cause),
+	ZeroCollateralRequirement: (_args, cause) => new ZeroCollateralRequirementError(cause),
+	InvalidTokenIdParameter: (args, cause) => new InvalidTokenIdParameterError(args[0], cause),
+	PositionNotOwned: (_args, cause) => new PositionNotOwnedError(cause),
+	PositionTooLarge: (_args, cause) => new PositionTooLargeError(cause),
+	PositionCountNotZero: (_args, cause) => new PositionCountNotZeroError(cause),
+	DuplicateTokenId: (_args, cause) => new DuplicateTokenIdError(cause),
+	TokenIdHasZeroLegs: (_args, cause) => new TokenIdHasZeroLegsError(cause),
+	TooManyLegsOpen: (_args, cause) => new TooManyLegsOpenError(cause),
+	InputListFail: (_args, cause) => new InputListFailError(cause),
+	InvalidTick: (_args, cause) => new InvalidTickError(cause),
+	InvalidTickBound: (_args, cause) => new InvalidTickBoundError(cause),
+	PriceBoundFail: (args, cause) => new PriceBoundFailError(args[0], cause),
+	PriceImpactTooLarge: (_args, cause) => new PriceImpactTooLargeError(cause),
+	ChunkHasZeroLiquidity: (_args, cause) => new ChunkHasZeroLiquidityError(cause),
+	LiquidityTooHigh: (_args, cause) => new LiquidityTooHighError(cause),
+	NetLiquidityZero: (_args, cause) => new NetLiquidityZeroError(cause),
+	EffectiveLiquidityAboveThreshold: (_args, cause) => new EffectiveLiquidityAboveThresholdError(cause),
+	StaleOracle: (_args, cause) => new StaleOracleError(cause),
+	NoLegsExercisable: (_args, cause) => new NoLegsExercisableError(cause),
+	NotALongLeg: (_args, cause) => new NotALongLegError(cause),
+	PoolNotInitialized: (_args, cause) => new PoolNotInitializedError(cause),
+	AlreadyInitialized: (_args, cause) => new AlreadyInitializedError(cause),
+	WrongPoolId: (_args, cause) => new WrongPoolIdError(cause),
+	WrongUniswapPool: (_args, cause) => new WrongUniswapPoolError(cause),
+	NotPanopticPool: (_args, cause) => new NotPanopticPoolError(cause),
+	NotGuardian: (_args, cause) => new NotGuardianError(cause),
+	NotBuilder: (_args, cause) => new NotBuilderError(cause),
+	InvalidBuilderCode: (_args, cause) => new InvalidBuilderCodeError(cause),
+	InvalidUniswapCallback: (_args, cause) => new InvalidUniswapCallbackError(cause),
+	UnauthorizedUniswapCallback: (_args, cause) => new UnauthorizedUniswapCallbackError(cause),
+	TransferFailed: (args, cause) => new TransferFailedError(args[0], args[1], args[2], args[3], cause),
+	CastingError: (_args, cause) => new CastingError(cause),
+	UnderOverFlow: (_args, cause) => new UnderOverFlowError(cause),
+	Reentrancy: (_args, cause) => new ReentrancyError(cause),
+	ZeroAddress: (_args, cause) => new ZeroAddressError(cause),
+	LengthMismatch: (_args, cause) => new LengthMismatchError(cause)
+};
+/**
+* Parse a raw contract error into a typed SDK error.
+*
+* This function attempts to decode the error data from a failed contract call
+* and return a typed error instance with extracted parameters.
+*
+* @param error - The raw error from a failed contract call
+* @returns Parsed error with typed error instance, or null if parsing fails
+*
+* @example
+* ```typescript
+* try {
+*   await contract.openPosition(...)
+* } catch (rawError) {
+*   const parsed = parsePanopticError(rawError)
+*   if (parsed) {
+*     console.log('Error:', parsed.errorName)
+*     if (parsed.error instanceof AccountInsolventError) {
+*       console.log('Solvent value:', parsed.error.solvent)
+*     }
+*   }
+* }
+* ```
+*/
+function parsePanopticError(error) {
+	const viemDecoded = extractViemDecodedError(error);
+	if (viemDecoded) return buildParsedError(viemDecoded.errorName, viemDecoded.args, error);
+	const errorData = extractErrorData(error);
+	if (!errorData) return null;
+	try {
+		const decoded = decodeErrorResult({
+			abi: combinedAbi,
+			data: errorData
+		});
+		return buildParsedError(decoded.errorName, decoded.args ?? [], error);
+	} catch {
+		if (errorData.length >= 10) {
+			const selector = errorData.slice(0, 10);
+			const match = matchSelectorToErrorName(selector);
+			if (match) return buildParsedError(match, [], error);
+		}
+		return null;
+	}
+}
+/**
+* Walk the cause chain looking for a viem ContractFunctionRevertedError
+* that already has decoded `.data` (an object with `errorName` and `args`).
+* This happens when the ABI passed to simulateContract includes the error definitions.
+*/
+function extractViemDecodedError(error) {
+	if (!error || typeof error !== "object") return null;
+	if (error instanceof BaseError) {
+		let found = null;
+		error.walk((e) => {
+			if (found) return false;
+			const node = e;
+			if (node.data && typeof node.data === "object" && "errorName" in node.data && typeof node.data.errorName === "string") {
+				const data = node.data;
+				found = {
+					errorName: data.errorName,
+					args: data.args ?? []
+				};
+				return true;
+			}
+			return false;
+		});
+		return found;
+	}
+	let current = error;
+	for (let i = 0; i < 10 && current; i++) {
+		if (current.data && typeof current.data === "object" && "errorName" in current.data && typeof current.data.errorName === "string") {
+			const data = current.data;
+			return {
+				errorName: data.errorName,
+				args: data.args ?? []
+			};
+		}
+		current = current.cause && typeof current.cause === "object" ? current.cause : null;
+	}
+	return null;
+}
+/**
+* Build a ParsedError from a decoded error name and args.
+*/
+function buildParsedError(errorName, args, originalError) {
+	const constructor = errorConstructors[errorName];
+	const cause = originalError instanceof Error ? originalError : void 0;
+	if (!constructor) {
+		const unknownError = new PanopticError(`Unknown contract error: ${errorName}`);
+		unknownError.errorName = errorName;
+		return {
+			error: unknownError,
+			errorName,
+			args
+		};
+	}
+	const typedError = constructor(args, cause);
+	typedError.errorName = errorName;
+	return {
+		error: typedError,
+		errorName,
+		args
+	};
+}
+/**
+* Match a 4-byte selector against the panoptic errors ABI.
+* Used as fallback when we only have the selector (no encoded args).
+*/
+function matchSelectorToErrorName(selector) {
+	for (const item of panopticErrorsAbi) {
+		if (item.type !== "error") continue;
+		const computed = toFunctionSelector(`${item.name}(${item.inputs.map((i) => i.type).join(",")})`);
+		if (computed === selector) return item.name;
+	}
+	return null;
+}
+/**
+* Extract error data from various error formats.
+*
+* Strategy:
+* 1. Use viem's BaseError.walk() to traverse the full cause chain and find
+*    hex data on any node (handles arbitrary nesting depth for multicall etc.)
+* 2. Fall back to manual cause-chain walk for non-viem errors
+* 3. Last resort: extract selector from error message (loses args)
+*/
+function extractErrorData(error) {
+	if (!error) return null;
+	if (typeof error === "string" && error.startsWith("0x")) return error;
+	if (typeof error !== "object") return null;
+	if (error instanceof BaseError) {
+		let foundData = null;
+		error.walk((e) => {
+			if (foundData) return false;
+			const node = e;
+			if (typeof node.raw === "string" && node.raw.startsWith("0x") && node.raw.length > 10) {
+				foundData = node.raw;
+				return true;
+			}
+			if (node.data && typeof node.data === "string" && node.data.startsWith("0x")) {
+				foundData = node.data;
+				return true;
+			}
+			if (node.data && typeof node.data === "object") {
+				const nested = node.data;
+				if (nested.data && typeof nested.data === "string" && nested.data.startsWith("0x")) {
+					foundData = nested.data;
+					return true;
+				}
+			}
+			return false;
+		});
+		if (foundData) return foundData;
+		error.walk((e) => {
+			if (foundData) return false;
+			const node = e;
+			if (node.signature && typeof node.signature === "string" && node.signature.startsWith("0x")) {
+				foundData = node.signature;
+				return true;
+			}
+			return false;
+		});
+		if (foundData) return foundData;
+	}
+	let current = error;
+	const maxDepth = 10;
+	for (let i = 0; i < maxDepth && current; i++) {
+		if (typeof current.raw === "string" && current.raw.startsWith("0x") && current.raw.length > 10) return current.raw;
+		if (current.data && typeof current.data === "string" && current.data.startsWith("0x")) return current.data;
+		if (current.data && typeof current.data === "object") {
+			const nested = current.data;
+			if (nested.data && typeof nested.data === "string" && nested.data.startsWith("0x")) return nested.data;
+		}
+		if (current.error && typeof current.error === "object") {
+			const rpcError = current.error;
+			if (rpcError.data && typeof rpcError.data === "string" && rpcError.data.startsWith("0x")) return rpcError.data;
+		}
+		current = current.cause && typeof current.cause === "object" ? current.cause : null;
+	}
+	const obj = error;
+	if (obj.message && typeof obj.message === "string") {
+		const signatureMatch = obj.message.match(/signature:?\s*["']?(0x[a-fA-F0-9]{8,})/i);
+		if (signatureMatch) return signatureMatch[1];
+	}
+	return null;
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/utils.ts
+/**
+* Decode PositionBalance packed data.
+*
+* Layout (from LSB to MSB):
+* - positionSize:     bits 0-127   (uint128)
+* - poolUtilization0: bits 128-143 (uint16)
+* - poolUtilization1: bits 144-159 (uint16)
+* - tickAtMint:       bits 160-183 (int24)
+* - timestampAtMint:  bits 184-215 (uint32)
+* - blockAtMint:      bits 216-254 (uint39)
+* - swapAtMint:       bit 255      (bool)
+*/
+function decodePositionBalance(balanceData) {
+	const positionSize = balanceData & (1n << 128n) - 1n;
+	const poolUtilization0 = balanceData >> 128n & 0xffffn;
+	const poolUtilization1 = balanceData >> 144n & 0xffffn;
+	let tickAtMint = balanceData >> 160n & 0xffffffn;
+	if (tickAtMint > 0x7fffffn) tickAtMint = tickAtMint - 0x1000000n;
+	const timestampAtMint = balanceData >> 184n & 0xffffffffn;
+	const blockAtMint = balanceData >> 216n & (1n << 39n) - 1n;
+	const swapAtMint = balanceData >> 255n === 1n;
+	return {
+		positionSize,
+		poolUtilization0,
+		poolUtilization1,
+		tickAtMint,
+		timestampAtMint,
+		blockAtMint,
+		swapAtMint
+	};
+}
+/**
+* Decode LeftRightSigned packed value.
+*/
+function decodeLeftRightSigned(value) {
+	let right = value & (1n << 128n) - 1n;
+	let left = value >> 128n;
+	if (right >= 1n << 127n) right = right - (1n << 128n);
+	if (left >= 1n << 127n) left = left - (1n << 128n);
+	return {
+		right,
+		left
+	};
+}
+/**
+* Parse Panoptic events from transaction logs.
+*
+* @param logs - The transaction logs
+* @returns Parsed Panoptic events
+*/
+function parsePanopticEvents(logs) {
+	const events = [];
+	for (const log of logs) {
+		const baseEvent = {
+			blockNumber: log.blockNumber ?? 0n,
+			blockHash: log.blockHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+			transactionHash: log.transactionHash ?? "0x",
+			logIndex: BigInt(log.logIndex ?? 0)
+		};
+		try {
+			const poolEvent = decodeEventLog({
+				abi: panopticPoolV2Abi,
+				data: log.data,
+				topics: log.topics
+			});
+			if (poolEvent.eventName === "OptionMinted") {
+				const args = poolEvent.args;
+				const balance = decodePositionBalance(args.balanceData);
+				events.push({
+					type: "OptionMinted",
+					...baseEvent,
+					recipient: args.recipient,
+					tokenId: args.tokenId,
+					positionSize: balance.positionSize,
+					poolUtilization0: balance.poolUtilization0,
+					poolUtilization1: balance.poolUtilization1,
+					tickAtMint: balance.tickAtMint,
+					timestampAtMint: balance.timestampAtMint,
+					blockAtMint: balance.blockAtMint,
+					swapAtMint: balance.swapAtMint
+				});
+			} else if (poolEvent.eventName === "OptionBurnt") {
+				const args = poolEvent.args;
+				events.push({
+					type: "OptionBurnt",
+					...baseEvent,
+					recipient: args.recipient,
+					tokenId: args.tokenId,
+					positionSize: args.positionSize,
+					premiaByLeg: [
+						args.premiaByLeg[0] ?? 0n,
+						args.premiaByLeg[1] ?? 0n,
+						args.premiaByLeg[2] ?? 0n,
+						args.premiaByLeg[3] ?? 0n
+					]
+				});
+			} else if (poolEvent.eventName === "AccountLiquidated") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.bonusAmounts);
+				events.push({
+					type: "AccountLiquidated",
+					...baseEvent,
+					liquidator: args.liquidator,
+					liquidatee: args.liquidatee,
+					bonusAmount0: right,
+					bonusAmount1: left
+				});
+			} else if (poolEvent.eventName === "ForcedExercised") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.exerciseFee);
+				events.push({
+					type: "ForcedExercised",
+					...baseEvent,
+					exercisor: args.exercisor,
+					user: args.user,
+					tokenId: args.tokenId,
+					exerciseFee0: right,
+					exerciseFee1: left
+				});
+			} else if (poolEvent.eventName === "PremiumSettled") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.settledAmounts);
+				events.push({
+					type: "PremiumSettled",
+					...baseEvent,
+					user: args.user,
+					tokenId: args.tokenId,
+					legIndex: args.legIndex,
+					settledAmount0: right,
+					settledAmount1: left
+				});
+			}
+		} catch {
+			try {
+				const collateralEvent = decodeEventLog({
+					abi: collateralTrackerV2Abi,
+					data: log.data,
+					topics: log.topics
+				});
+				if (collateralEvent.eventName === "Deposit") {
+					const args = collateralEvent.args;
+					events.push({
+						type: "Deposit",
+						...baseEvent,
+						sender: args.sender,
+						owner: args.owner,
+						assets: args.assets,
+						shares: args.shares
+					});
+				} else if (collateralEvent.eventName === "Withdraw") {
+					const args = collateralEvent.args;
+					events.push({
+						type: "Withdraw",
+						...baseEvent,
+						sender: args.sender,
+						receiver: args.receiver,
+						owner: args.owner,
+						assets: args.assets,
+						shares: args.shares
+					});
+				}
+			} catch {}
+		}
+	}
+	return events;
+}
+/**
+* Create a TxResult from a transaction hash.
+*
+* @param client - The public client
+* @param hash - The transaction hash
+* @returns TxResult with wait function
+*/
+function createTxResult(client, hash) {
+	return {
+		hash,
+		wait: async (confirmations) => {
+			const receipt = await client.waitForTransactionReceipt({
+				hash,
+				confirmations: confirmations !== void 0 ? Number(confirmations) : void 0
+			});
+			const events = parsePanopticEvents(receipt.logs);
+			return {
+				hash: receipt.transactionHash,
+				blockNumber: receipt.blockNumber,
+				blockHash: receipt.blockHash,
+				gasUsed: receipt.gasUsed,
+				status: receipt.status === "success" ? "success" : "reverted",
+				events
+			};
+		}
+	};
+}
+/**
+* Submit a write operation, supporting both direct wallet submission
+* and custom broadcaster paths with gas overrides.
+*
+* Normal path (no broadcaster): calls walletClient.writeContract() with gas overrides.
+* Broadcaster path: prepareTransactionRequest → apply overrides → signTransaction → broadcast.
+*
+* @param params - Submit write parameters
+* @returns TxResult
+*/
+async function submitWrite(params) {
+	try {
+		return await submitWriteRequest({
+			...params,
+			abi: [...params.abi, ...panopticErrorsAbi]
+		});
+	} catch (error) {
+		if (error instanceof PanopticError) throw error;
+		throw parsePanopticError(error)?.error ?? error;
+	}
+}
+async function submitWriteRequest(params) {
+	const { client, walletClient, account, address, abi, functionName, args, value, txOverrides } = params;
+	const broadcaster = txOverrides?.broadcaster;
+	if (broadcaster) {
+		const data = encodeFunctionData({
+			abi,
+			functionName,
+			args
+		});
+		const broadcastAccount = walletClient.account ?? account;
+		const request = await walletClient.prepareTransactionRequest({
+			account: broadcastAccount,
+			to: address,
+			chain: walletClient.chain,
+			data,
+			...value !== void 0 && { value },
+			...txOverrides?.maxFeePerGas !== void 0 && { maxFeePerGas: txOverrides.maxFeePerGas },
+			...txOverrides?.maxPriorityFeePerGas !== void 0 && { maxPriorityFeePerGas: txOverrides.maxPriorityFeePerGas },
+			...txOverrides?.gas !== void 0 && { gas: txOverrides.gas },
+			...txOverrides?.nonce !== void 0 && { nonce: Number(txOverrides.nonce) }
+		});
+		const signedTx = await walletClient.signTransaction({
+			...request,
+			account: broadcastAccount
+		});
+		const hash$1 = await broadcaster.broadcast(signedTx);
+		return createTxResult(client, hash$1);
+	}
+	const gasOverrides = {};
+	if (txOverrides?.maxFeePerGas !== void 0) gasOverrides.maxFeePerGas = txOverrides.maxFeePerGas;
+	if (txOverrides?.maxPriorityFeePerGas !== void 0) gasOverrides.maxPriorityFeePerGas = txOverrides.maxPriorityFeePerGas;
+	if (txOverrides?.nonce !== void 0) gasOverrides.nonce = Number(txOverrides.nonce);
+	const resolvedAccount = walletClient.account ?? account;
+	if (txOverrides?.gas !== void 0) gasOverrides.gas = txOverrides.gas;
+	else {
+		const estimated = await client.estimateContractGas({
+			address,
+			abi,
+			functionName,
+			args,
+			account: resolvedAccount,
+			...value !== void 0 && { value }
+		});
+		gasOverrides.gas = estimated * 120n / 100n;
+	}
+	const hash = await walletClient.writeContract({
+		address,
+		abi,
+		functionName,
+		args,
+		account: resolvedAccount,
+		chain: walletClient.chain,
+		...value !== void 0 && { value },
+		...gasOverrides
+	});
+	return createTxResult(client, hash);
+}
 
 //#endregion
 //#region src/panoptic/v2/utils/constants.ts