@panoptic-eng/sdk 1.0.72 → 1.0.74

package/dist/{rates-BOGkyjVy.js → rates-B9HaWnEM.js}

@@ -7584,211 +7584,503 @@ const semiFungiblePositionManagerV4Abi = [
 ];
 
 //#endregion
-//#region src/panoptic/v2/clients/blockMeta.ts
-/**
-* Get block metadata for a given block.
-* Used to tag all read results with same-block consistency proof.
-*
-* @param params - The parameters
-* @returns Block metadata
-*/
-async function getBlockMeta(params) {
-	const { client, blockNumber } = params;
-	const block = await client.getBlock({
-		blockNumber,
-		includeTransactions: false
-	});
-	return {
-		blockNumber: block.number,
-		blockHash: block.hash,
-		blockTimestamp: block.timestamp
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/errors/base.ts
-/**
-* Base error class for the Panoptic v2 SDK.
-* @module v2/errors/base
-*/
+//#region src/panoptic/v2/abis/stateView.ts
 /**
-* 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)
-*   }
-* }
-* ```
+* Minimal Uniswap V4 StateView ABI for fee growth reads.
+* Only includes functions needed by streamia history.
 */
-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);
+const stateViewAbi = [
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getSlot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint24",
+				name: "protocolFee",
+				type: "uint24"
+			},
+			{
+				internalType: "uint24",
+				name: "lpFee",
+				type: "uint24"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getFeeGrowthGlobals",
+		outputs: [{
+			internalType: "uint256",
+			name: "feeGrowthGlobal0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "feeGrowthGlobal1",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}, {
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		}],
+		name: "getTickInfo",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getLiquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "liquidity",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
 	}
-};
+];
 
 //#endregion
-//#region src/panoptic/v2/errors/contract.ts
-/**
-* The account is not solvent enough to perform the desired action.
-* @see Errors.sol:9
-*/
-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;
-	}
-};
-/**
-* Position is still solvent and cannot be liquidated.
-* @see Errors.sol:84
-*/
-var NotMarginCalledError = class extends PanopticError {
-	name = "NotMarginCalledError";
-	constructor(cause) {
-		super("Position is still solvent and cannot be liquidated", cause);
-	}
-};
-/**
-* The user does not own enough assets to open/close a position.
-* @see Errors.sol:78
-*/
-var NotEnoughTokensError = class extends PanopticError {
-	name = "NotEnoughTokensError";
-	get deficit() {
-		return this.assetsRequested > this.assetBalance ? this.assetsRequested - this.assetBalance : 0n;
-	}
-	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;
-	}
-};
-/**
-* There is not enough available liquidity in the chunk for a long leg.
-* @see Errors.sol:75
-*/
-var NotEnoughLiquidityInChunkError = class extends PanopticError {
-	name = "NotEnoughLiquidityInChunkError";
-	constructor(cause) {
-		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
-	}
-};
-/**
-* 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);
-	}
-};
-/**
-* 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);
-	}
-};
-/**
-* Attempted to withdraw/redeem less than a single asset.
-* @see Errors.sol:16
-*/
-var BelowMinimumRedemptionError = class extends PanopticError {
-	name = "BelowMinimumRedemptionError";
-	constructor(cause) {
-		super("Redemption amount below minimum threshold", cause);
-	}
-};
+//#region src/panoptic/v2/abis/uniswapV3Pool.ts
 /**
-* Attempted to withdraw/redeem more than available.
-* @see Errors.sol:35
+* Minimal Uniswap V3 Pool ABI for fee growth reads.
+* Only includes functions needed by streamia history.
 */
-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);
+const uniswapV3PoolAbi = [
+	{
+		inputs: [],
+		name: "slot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint16",
+				name: "observationIndex",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinality",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinalityNext",
+				type: "uint16"
+			},
+			{
+				internalType: "uint8",
+				name: "feeProtocol",
+				type: "uint8"
+			},
+			{
+				internalType: "bool",
+				name: "unlocked",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal0X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal1X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		name: "ticks",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulativeOutside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityOutsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsOutside",
+				type: "uint32"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "liquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "fee",
+		outputs: [{
+			internalType: "uint24",
+			name: "",
+			type: "uint24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token0",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token1",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "tickSpacing",
+		outputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		stateMutability: "view",
+		type: "function"
 	}
-};
+];
+
+//#endregion
+//#region src/panoptic/v2/clients/blockMeta.ts
 /**
-* The TokenId provided is malformed or invalid.
-* @see Errors.sol:54
+* Get block metadata for a given block.
+* Used to tag all read results with same-block consistency proof.
+*
+* @param params - The parameters
+* @returns Block metadata
 */
-var InvalidTokenIdParameterError = class extends PanopticError {
-	name = "InvalidTokenIdParameterError";
-	/**
-	* Parameter type meanings:
-	* 0=poolId, 1=ratio, 2=tokenType, 3=riskPartner, 4=strike, 5=width, 6=duplicateChunk
-	*/
-	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;
-	}
-};
+async function getBlockMeta(params) {
+	const { client, blockNumber } = params;
+	const block = await client.getBlock({
+		blockNumber,
+		includeTransactions: false
+	});
+	return {
+		blockNumber: block.number,
+		blockHash: block.hash,
+		blockTimestamp: block.timestamp
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/errors/base.ts
 /**
-* Position is not owned by the user and has positionSize=0.
-* @see Errors.sol:96
+* Base error class for the Panoptic v2 SDK.
+* @module v2/errors/base
 */
-var PositionNotOwnedError = class extends PanopticError {
-	name = "PositionNotOwnedError";
-	constructor(cause) {
-		super("Position is not owned by the user", cause);
-	}
-};
 /**
-* The maximum token deltas for a position exceed limits.
-* @see Errors.sol:99
+* 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)
+*   }
+* }
+* ```
 */
-var PositionTooLargeError = class extends PanopticError {
-	name = "PositionTooLargeError";
-	constructor(cause) {
-		super("Position size exceeds maximum allowed token deltas", cause);
-	}
+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
+/**
+* The account is not solvent enough to perform the desired action.
+* @see Errors.sol:9
+*/
+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;
+	}
+};
+/**
+* Position is still solvent and cannot be liquidated.
+* @see Errors.sol:84
+*/
+var NotMarginCalledError = class extends PanopticError {
+	name = "NotMarginCalledError";
+	constructor(cause) {
+		super("Position is still solvent and cannot be liquidated", cause);
+	}
+};
+/**
+* The user does not own enough assets to open/close a position.
+* @see Errors.sol:78
+*/
+var NotEnoughTokensError = class extends PanopticError {
+	name = "NotEnoughTokensError";
+	get deficit() {
+		return this.assetsRequested > this.assetBalance ? this.assetsRequested - this.assetBalance : 0n;
+	}
+	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;
+	}
+};
+/**
+* There is not enough available liquidity in the chunk for a long leg.
+* @see Errors.sol:75
+*/
+var NotEnoughLiquidityInChunkError = class extends PanopticError {
+	name = "NotEnoughLiquidityInChunkError";
+	constructor(cause) {
+		super("Not enough liquidity in chunk for long leg creation or short leg closure", cause);
+	}
+};
+/**
+* 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);
+	}
+};
+/**
+* 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);
+	}
+};
+/**
+* Attempted to withdraw/redeem less than a single asset.
+* @see Errors.sol:16
+*/
+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";
+	/**
+	* Parameter type meanings:
+	* 0=poolId, 1=ratio, 2=tokenType, 3=riskPartner, 4=strike, 5=width, 6=duplicateChunk
+	*/
+	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;
+	}
+};
+/**
+* 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);
+	}
+};
+/**
+* The maximum token deltas for a position exceed limits.
+* @see Errors.sol:99
+*/
+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.
@@ -9276,315 +9568,23 @@ async function submitWriteRequest(params) {
 			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/abis/stateView.ts
-/**
-* Minimal Uniswap V4 StateView ABI for fee growth reads.
-* Only includes functions needed by streamia history.
-*/
-const stateViewAbi = [
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getSlot0",
-		outputs: [
-			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
-			},
-			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
-			},
-			{
-				internalType: "uint24",
-				name: "protocolFee",
-				type: "uint24"
-			},
-			{
-				internalType: "uint24",
-				name: "lpFee",
-				type: "uint24"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getFeeGrowthGlobals",
-		outputs: [{
-			internalType: "uint256",
-			name: "feeGrowthGlobal0",
-			type: "uint256"
-		}, {
-			internalType: "uint256",
-			name: "feeGrowthGlobal1",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}, {
-			internalType: "int24",
-			name: "tick",
-			type: "int24"
-		}],
-		name: "getTickInfo",
-		outputs: [
-			{
-				internalType: "uint128",
-				name: "liquidityGross",
-				type: "uint128"
-			},
-			{
-				internalType: "int128",
-				name: "liquidityNet",
-				type: "int128"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside0X128",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside1X128",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getLiquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "liquidity",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
-	}
-];
-
-//#endregion
-//#region src/panoptic/v2/abis/uniswapV3Pool.ts
-/**
-* Minimal Uniswap V3 Pool ABI for fee growth reads.
-* Only includes functions needed by streamia history.
-*/
-const uniswapV3PoolAbi = [
-	{
-		inputs: [],
-		name: "slot0",
-		outputs: [
-			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
-			},
-			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
-			},
-			{
-				internalType: "uint16",
-				name: "observationIndex",
-				type: "uint16"
-			},
-			{
-				internalType: "uint16",
-				name: "observationCardinality",
-				type: "uint16"
-			},
-			{
-				internalType: "uint16",
-				name: "observationCardinalityNext",
-				type: "uint16"
-			},
-			{
-				internalType: "uint8",
-				name: "feeProtocol",
-				type: "uint8"
-			},
-			{
-				internalType: "bool",
-				name: "unlocked",
-				type: "bool"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "feeGrowthGlobal0X128",
-		outputs: [{
-			internalType: "uint256",
-			name: "",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "feeGrowthGlobal1X128",
-		outputs: [{
-			internalType: "uint256",
-			name: "",
-			type: "uint256"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "int24",
-			name: "",
-			type: "int24"
-		}],
-		name: "ticks",
-		outputs: [
-			{
-				internalType: "uint128",
-				name: "liquidityGross",
-				type: "uint128"
-			},
-			{
-				internalType: "int128",
-				name: "liquidityNet",
-				type: "int128"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside0X128",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "feeGrowthOutside1X128",
-				type: "uint256"
-			},
-			{
-				internalType: "int56",
-				name: "tickCumulativeOutside",
-				type: "int56"
-			},
-			{
-				internalType: "uint160",
-				name: "secondsPerLiquidityOutsideX128",
-				type: "uint160"
-			},
-			{
-				internalType: "uint32",
-				name: "secondsOutside",
-				type: "uint32"
-			},
-			{
-				internalType: "bool",
-				name: "initialized",
-				type: "bool"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "liquidity",
-		outputs: [{
-			internalType: "uint128",
-			name: "",
-			type: "uint128"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "fee",
-		outputs: [{
-			internalType: "uint24",
-			name: "",
-			type: "uint24"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "token0",
-		outputs: [{
-			internalType: "address",
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "token1",
-		outputs: [{
-			internalType: "address",
-			name: "",
-			type: "address"
-		}],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [],
-		name: "tickSpacing",
-		outputs: [{
-			internalType: "int24",
-			name: "",
-			type: "int24"
-		}],
-		stateMutability: "view",
-		type: "function"
+			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/oraclePack.ts
@@ -10682,7 +10682,7 @@ const decodeWidth = (leg) => (leg >> WIDTH_STARTING_BIT) % (1n << WIDTH_SIZE);
 * Extract tickSpacing from a TokenId
 * TickSpacing is stored in bits 48-63 (16 bits) of the poolId
 */
-const decodeTickSpacing = (tokenId) => {
+const decodeTickSpacing$1 = (tokenId) => {
 	return tokenId % (1n << POOL_ID_SIZE) >> TICK_SPACING_STARTING_BIT;
 };
 const decodePosition = (encodedPosition) => {
@@ -10772,7 +10772,7 @@ async function getPosition(params) {
 	const balanceRaw = fullData[2][0];
 	const { positionSize, poolUtilization0: utilization0AtMint, poolUtilization1: utilization1AtMint, tickAtMint, timestampAtMint, blockAtMint, swapAtMint } = decodePositionBalance(balanceRaw);
 	const decoded = decodePosition(tokenId);
-	const tickSpacing = decodeTickSpacing(tokenId);
+	const tickSpacing = decodeTickSpacing$1(tokenId);
 	const legs = decoded.legs.map((leg) => {
 		const width = leg.width;
 		const strike = leg.strike;
@@ -10842,7 +10842,7 @@ async function getPositions(params) {
 			const { positionSize, poolUtilization0: utilization0AtMint, poolUtilization1: utilization1AtMint, tickAtMint, timestampAtMint, blockAtMint, swapAtMint } = decodePositionBalance(balanceRaw);
 			if (positionSize === 0n) continue;
 			const decoded = decodePosition(tokenId);
-			const tickSpacing = decodeTickSpacing(tokenId);
+			const tickSpacing = decodeTickSpacing$1(tokenId);
 			const legs = decoded.legs.map((leg) => {
 				const width = leg.width;
 				const strike = leg.strike;
@@ -10981,7 +10981,7 @@ async function getPositionGreeks(params) {
 	]);
 	const { tickAtMint, positionSize } = decodePositionBalance(fullData[2][0]);
 	const decoded = decodePosition(tokenId);
-	const tickSpacing = decodeTickSpacing(tokenId);
+	const tickSpacing = decodeTickSpacing$1(tokenId);
 	const legs = decoded.legs.map((leg) => {
 		const width = leg.width;
 		const strike = leg.strike;
@@ -11014,6 +11014,630 @@ async function getPositionGreeks(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/tokenId/encoding.ts
+/**
+* Convert a signed strike tick to unsigned representation for encoding.
+*
+* @param strike - The signed strike tick
+* @returns The unsigned representation
+*/
+function convertStrikeToUnsigned(strike) {
+	if (strike < 0n) return STRIKE_CONVERSION_FACTOR + strike;
+	return strike;
+}
+/**
+* Convert an unsigned encoded strike back to signed representation.
+*
+* @param encodedStrike - The unsigned encoded strike
+* @returns The signed strike tick
+*/
+function convertStrikeToSigned(encodedStrike) {
+	if (encodedStrike > 2n ** 23n - 1n) return encodedStrike - STRIKE_CONVERSION_FACTOR;
+	return encodedStrike;
+}
+/**
+* Get the bit offset for a leg at the given index.
+*
+* @param legIndex - The leg index (0-3)
+* @returns The bit offset from the start of the legs section
+*/
+function getLegOffset(legIndex) {
+	return legIndex * TOKEN_ID_BITS.LEG_SIZE;
+}
+/**
+* Encode a pool ID from a Uniswap V3 pool address.
+*
+* The encoded PoolId structure: [16-bit tickSpacing][8-bit vegoid][40-bit pool address]
+*
+* @param address - The Uniswap V3 pool address
+* @param tickSpacing - The tick spacing of the pool
+* @param vegoid - The vegoid value (defaults to 4)
+* @returns The encoded pool ID
+*/
+function encodePoolId(address, tickSpacing, vegoid$1 = DEFAULT_VEGOID) {
+	const addressHex = address.slice(2, 12).toLowerCase();
+	const bytes = [];
+	for (let i = 0; i < 10; i += 2) bytes.push(parseInt(addressHex.slice(i, i + 2), 16));
+	bytes.reverse();
+	let poolId = 0n;
+	for (let i = 0; i < bytes.length; i++) poolId |= BigInt(bytes[i]) << BigInt(i * 8);
+	poolId |= (vegoid$1 & 0xffn) << TOKEN_ID_BITS.VEGOID_STARTING_BIT;
+	poolId |= (tickSpacing & 0xffffn) << TOKEN_ID_BITS.TICK_SPACING_STARTING_BIT;
+	return poolId;
+}
+/**
+* Encode a pool ID from a Uniswap V4 pool ID (bytes32).
+*
+* @param poolIdHex - The V4 pool ID (bytes32 hex string)
+* @param tickSpacing - The tick spacing of the pool
+* @param vegoid - The vegoid value (defaults to 4)
+* @returns The encoded pool ID
+*/
+function encodeV4PoolId(poolIdHex, tickSpacing, vegoid$1 = DEFAULT_VEGOID) {
+	const hex = poolIdHex.slice(2);
+	const last5BytesHex = hex.slice(-10).toLowerCase();
+	const bytes = [];
+	for (let i = 0; i < 10; i += 2) bytes.push(parseInt(last5BytesHex.slice(i, i + 2), 16));
+	bytes.reverse();
+	let encodedPoolId = 0n;
+	for (let i = 0; i < bytes.length; i++) encodedPoolId |= BigInt(bytes[i]) << BigInt(i * 8);
+	encodedPoolId |= (vegoid$1 & 0xffn) << TOKEN_ID_BITS.VEGOID_STARTING_BIT;
+	encodedPoolId |= (tickSpacing & 0xffffn) << TOKEN_ID_BITS.TICK_SPACING_STARTING_BIT;
+	return encodedPoolId;
+}
+/**
+* Decode the vegoid from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @returns The vegoid value
+*/
+function decodeVegoid(tokenId) {
+	const poolId = tokenId & (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+	return poolId >> TOKEN_ID_BITS.VEGOID_STARTING_BIT & (1n << TOKEN_ID_BITS.VEGOID_SIZE) - 1n;
+}
+/**
+* Decode the tick spacing from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @returns The tick spacing
+*/
+function decodeTickSpacing(tokenId) {
+	const poolId = tokenId & (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+	return poolId >> TOKEN_ID_BITS.TICK_SPACING_STARTING_BIT;
+}
+/**
+* Decode the pool ID portion from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @returns The pool ID as a hex string
+*/
+function decodePoolId(tokenId) {
+	const poolId = tokenId & (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+	let hex = poolId.toString(16);
+	while (hex.length < 16) hex = "0" + hex;
+	return `0x${hex}`;
+}
+/**
+* Encode a single leg field.
+*
+* @param value - The value to encode
+* @param bitPosition - The bit position within the leg
+* @param legIndex - The leg index
+* @returns The encoded value shifted to the correct position
+*/
+function encodeLegField(value, bitPosition, legIndex) {
+	return value << getLegOffset(legIndex) + bitPosition + TOKEN_ID_BITS.POOL_ID_SIZE;
+}
+/**
+* Encode a single leg into a TokenId.
+*
+* @param leg - The leg parameters
+* @returns The encoded leg value (to be ORed with existing TokenId)
+*/
+function encodeLeg(leg) {
+	const { index, asset, optionRatio, isLong, tokenType, riskPartner, strike, width } = leg;
+	return encodeLegField(asset & LEG_MASKS.ASSET, LEG_BITS.ASSET_BIT, index) | encodeLegField(optionRatio & LEG_MASKS.RATIO, LEG_BITS.RATIO_BIT, index) | encodeLegField(isLong & LEG_MASKS.IS_LONG, LEG_BITS.IS_LONG_BIT, index) | encodeLegField(tokenType & LEG_MASKS.TOKEN_TYPE, LEG_BITS.TOKEN_TYPE_BIT, index) | encodeLegField(riskPartner & LEG_MASKS.RISK_PARTNER, LEG_BITS.RISK_PARTNER_BIT, index) | encodeLegField(convertStrikeToUnsigned(strike) & LEG_MASKS.STRIKE, LEG_BITS.STRIKE_BIT, index) | encodeLegField(width & LEG_MASKS.WIDTH, LEG_BITS.WIDTH_BIT, index);
+}
+/**
+* Add a leg to an existing TokenId.
+*
+* @param tokenId - The existing TokenId (can be just poolId or partial TokenId)
+* @param leg - The leg parameters to add
+* @returns The TokenId with the leg added
+*/
+function addLegToTokenId(tokenId, leg) {
+	return tokenId | encodeLeg(leg);
+}
+/**
+* Decode a single leg from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @param legIndex - The leg index (0-3)
+* @returns The decoded leg data
+*/
+function decodeLeg(tokenId, legIndex) {
+	const offset = getLegOffset(legIndex) + TOKEN_ID_BITS.POOL_ID_SIZE;
+	const leg = tokenId >> offset & LEG_MASKS.LEG;
+	const asset = leg & LEG_MASKS.ASSET;
+	const optionRatio = leg >> LEG_BITS.RATIO_BIT & LEG_MASKS.RATIO;
+	const isLong = (leg >> LEG_BITS.IS_LONG_BIT & LEG_MASKS.IS_LONG) === 1n;
+	const tokenType = leg >> LEG_BITS.TOKEN_TYPE_BIT & LEG_MASKS.TOKEN_TYPE;
+	const riskPartner = leg >> LEG_BITS.RISK_PARTNER_BIT & LEG_MASKS.RISK_PARTNER;
+	const encodedStrike = leg >> LEG_BITS.STRIKE_BIT & LEG_MASKS.STRIKE;
+	const strike = convertStrikeToSigned(encodedStrike);
+	const width = leg >> LEG_BITS.WIDTH_BIT & LEG_MASKS.WIDTH;
+	return {
+		index: legIndex,
+		asset,
+		optionRatio,
+		isLong,
+		tokenType,
+		riskPartner,
+		strike,
+		width
+	};
+}
+/**
+* Count the number of active legs in a TokenId.
+* A leg is active if its optionRatio > 0.
+*
+* @param tokenId - The TokenId to check
+* @returns The number of active legs
+*/
+function countLegs(tokenId) {
+	let count = 0n;
+	for (let i = 0n; i < TOKEN_ID_BITS.MAX_LEGS; i++) {
+		const leg = decodeLeg(tokenId, i);
+		if (leg.optionRatio > 0n) count++;
+	}
+	return count;
+}
+/**
+* Decode all active legs from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @returns Array of decoded legs (only active legs with optionRatio > 0)
+*/
+function decodeAllLegs(tokenId) {
+	const legs = [];
+	for (let i = 0n; i < TOKEN_ID_BITS.MAX_LEGS; i++) {
+		const leg = decodeLeg(tokenId, i);
+		if (leg.optionRatio > 0n) legs.push(leg);
+	}
+	return legs;
+}
+
+//#endregion
+//#region src/panoptic/v2/tokenId/decode.ts
+/**
+* Convert a DecodedLeg to TokenIdLeg format.
+*
+* @param leg - The decoded leg from encoding utils
+* @param tickSpacing - The tick spacing for calculating tick bounds
+* @returns The TokenIdLeg format
+*/
+function convertToTokenIdLeg(leg, tickSpacing) {
+	const halfWidth = leg.width * tickSpacing / 2n;
+	const tickLower = leg.strike - halfWidth;
+	const tickUpper = leg.strike + halfWidth;
+	return {
+		index: leg.index,
+		asset: leg.asset,
+		optionRatio: leg.optionRatio,
+		isLong: leg.isLong,
+		tokenType: leg.tokenType,
+		riskPartner: leg.riskPartner,
+		strike: leg.strike,
+		width: leg.width,
+		tickLower,
+		tickUpper
+	};
+}
+/**
+* Decode a TokenId into its component parts.
+*
+* @param tokenId - The TokenId to decode
+* @returns The decoded TokenId data
+*
+* @example
+* ```typescript
+* const decoded = decodeTokenId(tokenId)
+* console.log(decoded.legs) // Array of legs
+* console.log(decoded.tickSpacing) // Tick spacing
+* ```
+*/
+function decodeTokenId(tokenId) {
+	const poolId = decodePoolId(tokenId);
+	const vegoid$1 = decodeVegoid(tokenId);
+	const tickSpacing = decodeTickSpacing(tokenId);
+	const rawLegs = decodeAllLegs(tokenId);
+	const numLegs = countLegs(tokenId);
+	const legs = rawLegs.map((leg) => convertToTokenIdLeg(leg, tickSpacing));
+	return {
+		tokenId,
+		poolId,
+		vegoid: vegoid$1,
+		tickSpacing,
+		legs,
+		legCount: numLegs
+	};
+}
+/**
+* Validate that a TokenId has the expected pool ID.
+*
+* @param tokenId - The TokenId to validate
+* @param expectedPoolId - The expected pool ID
+* @returns True if the pool IDs match
+*/
+function validatePoolId(tokenId, expectedPoolId) {
+	const actualPoolId = tokenId & (1n << 64n) - 1n;
+	return actualPoolId === expectedPoolId;
+}
+/**
+* Check if a TokenId represents a long position (any leg is long).
+*
+* @param tokenId - The TokenId to check
+* @returns True if any leg is long
+*/
+function hasLongLeg(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.isLong);
+}
+/**
+* Check if a TokenId represents a short-only position.
+*
+* @param tokenId - The TokenId to check
+* @returns True if all legs are short
+*/
+function isShortOnly(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every((leg) => !leg.isLong);
+}
+/**
+* Check if a TokenId represents a spread (legs with different risk partners).
+*
+* @param tokenId - The TokenId to check
+* @returns True if any leg has a different risk partner
+*/
+function isSpread(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.riskPartner !== leg.index);
+}
+/**
+* Get the asset index for a TokenId (from the first leg).
+*
+* @param tokenId - The TokenId
+* @returns The asset index (0 or 1), or undefined if no legs
+*/
+function getAssetIndex(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	if (legs.length === 0) return void 0;
+	return legs[0].asset;
+}
+/**
+* Check if a leg is a loan (width=0 and isLong=false).
+*
+* Loans borrow liquidity from the pool at a specific strike price.
+*
+* @param leg - The decoded leg to check
+* @returns True if the leg is a loan
+*/
+function isLoanLeg(leg) {
+	return leg.width === 0n && !leg.isLong;
+}
+/**
+* Check if a leg is a credit (width=0 and isLong=true).
+*
+* Credits lend liquidity to the pool at a specific strike price.
+*
+* @param leg - The decoded leg to check
+* @returns True if the leg is a credit
+*/
+function isCreditLeg(leg) {
+	return leg.width === 0n && leg.isLong;
+}
+/**
+* Check if a TokenId is a pure loan (all legs are loans).
+*
+* @param tokenId - The TokenId to check
+* @returns True if all legs are loans
+*/
+function isLoan(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every(isLoanLeg);
+}
+/**
+* Index of the borrowed token when a TokenId is a single-leg loan.
+*
+* Returns undefined for credits, multi-leg loans, and positions mixing loans
+* with options: closing those can move both tokens for reasons other than
+* repaying one borrowed principal.
+*
+* @param tokenId - The TokenId to classify
+* @returns The borrowed token index (the leg's tokenType), or undefined
+*/
+function getSimpleLoanTokenIndex(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	if (legs.length !== 1 || !isLoanLeg(legs[0])) return void 0;
+	return legs[0].tokenType === 0n ? 0n : 1n;
+}
+/**
+* Check if a TokenId is a pure credit (all legs are credits).
+*
+* @param tokenId - The TokenId to check
+* @returns True if all legs are credits
+*/
+function isCredit(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.length > 0 && legs.every(isCreditLeg);
+}
+/**
+* Check if a TokenId contains loan or credit legs (width=0).
+*
+* @param tokenId - The TokenId to check
+* @returns True if any leg has width=0 (loan or credit)
+*/
+function hasLoanOrCredit(tokenId) {
+	const legs = decodeAllLegs(tokenId);
+	return legs.some((leg) => leg.width === 0n);
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/premia.ts
+/**
+* Get streamia totals for an account.
+*
+* Returns the total short and long streamia across all positions.
+* Short streamia is owed TO the account (earned from selling options).
+* Long streamia is owed BY the account (paid for buying options).
+*
+* @param params - The parameters
+* @returns Streamia totals with block metadata
+*
+* @example
+* ```typescript
+* const streamia = await getAccountPremia({
+*   client,
+*   poolAddress,
+*   account,
+*   tokenIds: [tokenId1, tokenId2],
+*   includePendingPremium: true,
+* })
+*
+* console.log('Short streamia earned:', streamia.shortPremium0, streamia.shortPremium1)
+* console.log('Long streamia owed:', streamia.longPremium0, streamia.longPremium1)
+* ```
+*/
+async function getAccountPremia(params) {
+	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (tokenIds.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		return {
+			shortPremium0: 0n,
+			shortPremium1: 0n,
+			longPremium0: 0n,
+			longPremium1: 0n,
+			includePendingPremium,
+			_meta: _meta$1
+		};
+	}
+	const [[shortPremiumPacked, longPremiumPacked], _meta] = await Promise.all([client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			tokenIds
+		],
+		blockNumber: targetBlockNumber
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
+	const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
+	return {
+		shortPremium0: shortPremium.right,
+		shortPremium1: shortPremium.left,
+		longPremium0: longPremium.right,
+		longPremium1: longPremium.left,
+		includePendingPremium,
+		_meta
+	};
+}
+/**
+* Get positions with per-position streamia data.
+*
+* Uses multicall to batch individual getFullPositionsData calls
+* for each position, giving us per-position streamia in a single RPC request.
+*
+* @param params - The parameters
+* @returns Positions with streamia and totals with block metadata
+*
+* @example
+* ```typescript
+* const result = await getPositionsWithPremia({
+*   client,
+*   poolAddress,
+*   account,
+*   tokenIds: [tokenId1, tokenId2],
+* })
+*
+* for (const position of result.positions) {
+*   console.log('Position:', position.tokenId)
+*   console.log('Streamia:', position.premiaOwed0, position.premiaOwed1)
+* }
+* console.log('Total short streamia:', result.shortPremium0, result.shortPremium1)
+* ```
+*/
+async function getPositionsWithPremia(params) {
+	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (tokenIds.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		return {
+			positions: [],
+			shortPremium0: 0n,
+			shortPremium1: 0n,
+			longPremium0: 0n,
+			longPremium1: 0n,
+			includePendingPremium,
+			_meta: _meta$1
+		};
+	}
+	const contracts = tokenIds.map((tokenId) => ({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			[tokenId]
+		]
+	}));
+	const [multicallResults, _meta] = await Promise.all([client.multicall({
+		contracts,
+		blockNumber: targetBlockNumber,
+		allowFailure: true
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const positions = [];
+	let totalShortPremium0 = 0n;
+	let totalShortPremium1 = 0n;
+	let totalLongPremium0 = 0n;
+	let totalLongPremium1 = 0n;
+	for (let i = 0; i < tokenIds.length; i++) {
+		const tokenId = tokenIds[i];
+		const result = multicallResults[i];
+		if (result.status !== "success") continue;
+		const [shortPremiumPacked, longPremiumPacked, balances] = result.result;
+		const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
+		const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
+		totalShortPremium0 += shortPremium.right;
+		totalShortPremium1 += shortPremium.left;
+		totalLongPremium0 += longPremium.right;
+		totalLongPremium1 += longPremium.left;
+		const balanceData = balances[0];
+		if (balanceData === void 0) continue;
+		const positionSize = balanceData & (1n << 128n) - 1n;
+		if (positionSize === 0n) continue;
+		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;
+		const decoded = decodePosition(tokenId);
+		const tickSpacing = decodeTickSpacing$1(tokenId);
+		const legs = decoded.legs.map((leg) => {
+			const width = leg.width;
+			const strike = leg.strike;
+			const tickLower = strike - width * tickSpacing / 2n;
+			const tickUpper = strike + width * tickSpacing / 2n;
+			return {
+				index: BigInt(leg.index),
+				asset: leg.asset,
+				optionRatio: leg.optionRatio,
+				isLong: leg.isLong === 1n,
+				tokenType: leg.tokenType,
+				riskPartner: leg.riskPartner,
+				strike,
+				width,
+				tickLower,
+				tickUpper
+			};
+		});
+		const premiaOwed0 = shortPremium.right - longPremium.right;
+		const premiaOwed1 = shortPremium.left - longPremium.left;
+		positions.push({
+			tokenId,
+			positionSize,
+			owner: account,
+			poolAddress,
+			legs,
+			poolUtilization0AtMint: poolUtilization0,
+			poolUtilization1AtMint: poolUtilization1,
+			tickAtMint,
+			timestampAtMint,
+			blockNumberAtMint: blockAtMint,
+			swapAtMint,
+			premiaOwed0,
+			premiaOwed1,
+			assetIndex: legs.length > 0 ? legs[0].asset : 0n,
+			_meta
+		});
+	}
+	return {
+		positions,
+		shortPremium0: totalShortPremium0,
+		shortPremium1: totalShortPremium1,
+		longPremium0: totalLongPremium0,
+		longPremium1: totalLongPremium1,
+		includePendingPremium,
+		_meta
+	};
+}
+/**
+* Get the unsettled short streamia an account would forfeit by closing now.
+*
+* Calls `getFullPositionsData` twice in one multicall — once with
+* `includePendingPremium = true` (everything owed to the short legs) and once
+* with `false` (only what is available to collect). The difference is the
+* streamia still owed by buyers that has not been settled; closing before it
+* settles forfeits it. Settling buyers first (see `settlePremiumFrom`) moves
+* that streamia into the available bucket.
+*
+* @param params - The parameters
+* @returns Owed, available, and forfeitable streamia with block metadata
+*/
+async function getForfeitablePremium(params) {
+	const { client, poolAddress, account, tokenIds, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const contracts = [true, false].map((includePendingPremium) => ({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			includePendingPremium,
+			tokenIds
+		]
+	}));
+	const [multicallResults, _meta] = await Promise.all([client.multicall({
+		contracts,
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const owed = decodeLeftRightUnsigned(multicallResults[0][0]);
+	const available = decodeLeftRightUnsigned(multicallResults[1][0]);
+	const forfeit0 = owed.right > available.right ? owed.right - available.right : 0n;
+	const forfeit1 = owed.left > available.left ? owed.left - available.left : 0n;
+	return {
+		owed0: owed.right,
+		owed1: owed.left,
+		available0: available.right,
+		available1: available.left,
+		forfeit0,
+		forfeit1,
+		_meta
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/storage/fileStorage.ts
 /**
@@ -12070,4 +12694,4 @@ function formatPerSecondRateWadAsAprPct(ratePerSecondWad, precision) {
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTickLimitsError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MaxRetriesExceededError, MissingPositionIdsError, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NoLoanPositionsError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, ReentrancyError, RpcError, RpcResponseError, STANDARD_TICK_WIDTHS, STRIKE_CONVERSION_FACTOR, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePosition, decodePositionBalance$1 as decodePositionBalance, decodeSnapshotTransaction, decodeTickSpacing, diagnoseOracleSafeMode, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getBlockMeta, getClosedPositionsKey, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getRiskParameters, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, isPanopticErrorType, isPositionTracked, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, riskEngineMulticall, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode };
+export { AccountInsolventError, AlreadyInitializedError, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTickLimitsError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MaxRetriesExceededError, MissingPositionIdsError, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NoLoanPositionsError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, ReentrancyError, RpcError, RpcResponseError, STANDARD_TICK_WIDTHS, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, countLegs, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePoolId, decodePositionBalance$1 as decodePositionBalance, decodeSnapshotTransaction, decodeTickSpacing, decodeTokenId, decodeVegoid, diagnoseOracleSafeMode, encodeLeg, encodePoolId, encodeV4PoolId, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountPremia, getAssetIndex, getBlockMeta, getClosedPositionsKey, getForfeitablePremium, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getRiskParameters, getSchemaVersionKey, getSimpleLoanTokenIndex, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isLoan, isLoanLeg, isPanopticErrorType, isPositionTracked, isShortOnly, isSpread, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, riskEngineMulticall, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode, validatePoolId };