@panoptic-eng/sdk 1.0.5 → 1.0.6

package/dist/irm-CBrX8bjH.js

@@ -0,0 +1,2375 @@
+import { MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, PanopticValidationError, collateralTrackerV2Abi, decodeLeftRightUnsigned, getBlockMeta, getPool$1 as getPool, getPositions, panopticPoolV2Abi, riskEngineAbi, tickToSqrtPriceX96$1 as tickToSqrtPriceX96 } from "./position-FxaZi608.js";
+import { decodeFunctionResult, encodeFunctionData } from "viem";
+import { call } from "viem/actions";
+
+//#region src/abis/multicall3.ts
+const Multicall3Abi = [
+	{
+		inputs: [{
+			components: [{
+				internalType: "address",
+				name: "target",
+				type: "address"
+			}, {
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Call[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "aggregate",
+		outputs: [{
+			internalType: "uint256",
+			name: "blockNumber",
+			type: "uint256"
+		}, {
+			internalType: "bytes[]",
+			name: "returnData",
+			type: "bytes[]"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [
+				{
+					internalType: "address",
+					name: "target",
+					type: "address"
+				},
+				{
+					internalType: "bool",
+					name: "allowFailure",
+					type: "bool"
+				},
+				{
+					internalType: "bytes",
+					name: "callData",
+					type: "bytes"
+				}
+			],
+			internalType: "struct Multicall3.Call3[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "aggregate3",
+		outputs: [{
+			components: [{
+				internalType: "bool",
+				name: "success",
+				type: "bool"
+			}, {
+				internalType: "bytes",
+				name: "returnData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Result[]",
+			name: "returnData",
+			type: "tuple[]"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [
+				{
+					internalType: "address",
+					name: "target",
+					type: "address"
+				},
+				{
+					internalType: "bool",
+					name: "allowFailure",
+					type: "bool"
+				},
+				{
+					internalType: "uint256",
+					name: "value",
+					type: "uint256"
+				},
+				{
+					internalType: "bytes",
+					name: "callData",
+					type: "bytes"
+				}
+			],
+			internalType: "struct Multicall3.Call3Value[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "aggregate3Value",
+		outputs: [{
+			components: [{
+				internalType: "bool",
+				name: "success",
+				type: "bool"
+			}, {
+				internalType: "bytes",
+				name: "returnData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Result[]",
+			name: "returnData",
+			type: "tuple[]"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [{
+				internalType: "address",
+				name: "target",
+				type: "address"
+			}, {
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Call[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "blockAndAggregate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "blockNumber",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32",
+				name: "blockHash",
+				type: "bytes32"
+			},
+			{
+				components: [{
+					internalType: "bool",
+					name: "success",
+					type: "bool"
+				}, {
+					internalType: "bytes",
+					name: "returnData",
+					type: "bytes"
+				}],
+				internalType: "struct Multicall3.Result[]",
+				name: "returnData",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getBasefee",
+		outputs: [{
+			internalType: "uint256",
+			name: "basefee",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint256",
+			name: "blockNumber",
+			type: "uint256"
+		}],
+		name: "getBlockHash",
+		outputs: [{
+			internalType: "bytes32",
+			name: "blockHash",
+			type: "bytes32"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getBlockNumber",
+		outputs: [{
+			internalType: "uint256",
+			name: "blockNumber",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getChainId",
+		outputs: [{
+			internalType: "uint256",
+			name: "chainid",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getCurrentBlockCoinbase",
+		outputs: [{
+			internalType: "address",
+			name: "coinbase",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getCurrentBlockDifficulty",
+		outputs: [{
+			internalType: "uint256",
+			name: "difficulty",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getCurrentBlockGasLimit",
+		outputs: [{
+			internalType: "uint256",
+			name: "gaslimit",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getCurrentBlockTimestamp",
+		outputs: [{
+			internalType: "uint256",
+			name: "timestamp",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "address",
+			name: "addr",
+			type: "address"
+		}],
+		name: "getEthBalance",
+		outputs: [{
+			internalType: "uint256",
+			name: "balance",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getLastBlockHash",
+		outputs: [{
+			internalType: "bytes32",
+			name: "blockHash",
+			type: "bytes32"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bool",
+			name: "requireSuccess",
+			type: "bool"
+		}, {
+			components: [{
+				internalType: "address",
+				name: "target",
+				type: "address"
+			}, {
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Call[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "tryAggregate",
+		outputs: [{
+			components: [{
+				internalType: "bool",
+				name: "success",
+				type: "bool"
+			}, {
+				internalType: "bytes",
+				name: "returnData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Result[]",
+			name: "returnData",
+			type: "tuple[]"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bool",
+			name: "requireSuccess",
+			type: "bool"
+		}, {
+			components: [{
+				internalType: "address",
+				name: "target",
+				type: "address"
+			}, {
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}],
+			internalType: "struct Multicall3.Call[]",
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "tryBlockAndAggregate",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "blockNumber",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32",
+				name: "blockHash",
+				type: "bytes32"
+			},
+			{
+				components: [{
+					internalType: "bool",
+					name: "success",
+					type: "bool"
+				}, {
+					internalType: "bytes",
+					name: "returnData",
+					type: "bytes"
+				}],
+				internalType: "struct Multicall3.Result[]",
+				name: "returnData",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "payable",
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/abis/panopticQuery.ts
+/**
+* PanopticQuery contract ABI
+* Auto-generated from PanopticQuery.json
+* @module abis/panopticQuery
+*/
+const panopticQueryAbi = [
+	{
+		type: "constructor",
+		inputs: [{
+			name: "SFPM_",
+			type: "address",
+			internalType: "contract ISemiFungiblePositionManager"
+		}],
+		stateMutability: "payable"
+	},
+	{
+		type: "function",
+		name: "checkCollateral",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			}
+		],
+		outputs: [
+			{
+				name: "collateralBalances0",
+				type: "uint256[4]",
+				internalType: "uint256[4]"
+			},
+			{
+				name: "requiredCollaterals0",
+				type: "uint256[4]",
+				internalType: "uint256[4]"
+			},
+			{
+				name: "collateralBalances1",
+				type: "uint256[4]",
+				internalType: "uint256[4]"
+			},
+			{
+				name: "requiredCollaterals1",
+				type: "uint256[4]",
+				internalType: "uint256[4]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "checkCollateral",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			}
+		],
+		outputs: [{
+			name: "balancesAndRequired",
+			type: "uint256[4]",
+			internalType: "uint256[4]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "checkCollateralListOutput",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			}
+		],
+		outputs: [
+			{
+				name: "",
+				type: "uint256[2][]",
+				internalType: "uint256[2][]"
+			},
+			{
+				name: "",
+				type: "int256[]",
+				internalType: "int256[]"
+			},
+			{
+				name: "",
+				type: "int24[]",
+				internalType: "int24[]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "computeMedianObservedPrice",
+		inputs: [
+			{
+				name: "univ3pool",
+				type: "address",
+				internalType: "contract IUniswapV3Pool"
+			},
+			{
+				name: "cardinality",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "period",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		],
+		outputs: [{
+			name: "medianTick",
+			type: "int24",
+			internalType: "int24"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getChunkData",
+		inputs: [{
+			name: "pool",
+			type: "address",
+			internalType: "contract PanopticPool"
+		}, {
+			name: "positionIdList",
+			type: "uint256[]",
+			internalType: "TokenId[]"
+		}],
+		outputs: [{
+			name: "",
+			type: "uint256[2][4][]",
+			internalType: "uint256[2][4][]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "scanChunks",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "tickLower",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "tickUpper",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "width",
+				type: "int24",
+				internalType: "int24"
+			}
+		],
+		outputs: [
+			{
+				name: "strikes",
+				type: "int24[]",
+				internalType: "int24[]"
+			},
+			{
+				name: "netLiquidities",
+				type: "uint128[2][]",
+				internalType: "uint128[2][]"
+			},
+			{
+				name: "removedLiquidities",
+				type: "uint128[2][]",
+				internalType: "uint128[2][]"
+			},
+			{
+				name: "settledTokens",
+				type: "uint256[2][]",
+				internalType: "LeftRightUnsigned[2][]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getLiquidationPrices",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			}
+		],
+		outputs: [{
+			name: "liquidationPriceDown",
+			type: "int24",
+			internalType: "int24"
+		}, {
+			name: "liquidationPriceUp",
+			type: "int24",
+			internalType: "int24"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getMaxPositionSizeBounds",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "existingPositionIds",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "tokenId",
+				type: "uint256",
+				internalType: "TokenId"
+			}
+		],
+		outputs: [{
+			name: "maxSizeAtMinUtil",
+			type: "uint128",
+			internalType: "uint128"
+		}, {
+			name: "maxSizeAtMaxUtil",
+			type: "uint128",
+			internalType: "uint128"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getNetLiquidationValue",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "includePendingPremium",
+				type: "bool",
+				internalType: "bool"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			},
+			{
+				name: "atTicks",
+				type: "int24[]",
+				internalType: "int24[]"
+			}
+		],
+		outputs: [{
+			name: "value0",
+			type: "int256[]",
+			internalType: "int256[]"
+		}, {
+			name: "value1",
+			type: "int256[]",
+			internalType: "int256[]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getNetLiquidationValue",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "includePendingPremium",
+				type: "bool",
+				internalType: "bool"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			}
+		],
+		outputs: [{
+			name: "value0",
+			type: "int256",
+			internalType: "int256"
+		}, {
+			name: "value1",
+			type: "int256",
+			internalType: "int256"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getPortfolioValue",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			}
+		],
+		outputs: [{
+			name: "value0",
+			type: "int256",
+			internalType: "int256"
+		}, {
+			name: "value1",
+			type: "int256",
+			internalType: "int256"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getRequiredBase",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "tokenId",
+				type: "uint256",
+				internalType: "TokenId"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			}
+		],
+		outputs: [{
+			name: "",
+			type: "uint256",
+			internalType: "uint256"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getTickNets",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "startTick",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "nTicks",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		],
+		outputs: [{
+			name: "tickData",
+			type: "int256[]",
+			internalType: "int256[]"
+		}, {
+			name: "liquidityNets",
+			type: "int256[]",
+			internalType: "int256[]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getTickNetsV3",
+		inputs: [
+			{
+				name: "univ3pool",
+				type: "address",
+				internalType: "contract IUniswapV3Pool"
+			},
+			{
+				name: "startTick",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "nTicks",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		],
+		outputs: [{
+			name: "tickData",
+			type: "int256[]",
+			internalType: "int256[]"
+		}, {
+			name: "liquidityNets",
+			type: "int256[]",
+			internalType: "int256[]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getTickNetsV4",
+		inputs: [
+			{
+				name: "manager",
+				type: "address",
+				internalType: "contract IPoolManager"
+			},
+			{
+				name: "poolId",
+				type: "bytes32",
+				internalType: "PoolId"
+			},
+			{
+				name: "tickSpacing",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "startTick",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "nTicks",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		],
+		outputs: [{
+			name: "tickData",
+			type: "int256[]",
+			internalType: "int256[]"
+		}, {
+			name: "liquidityNets",
+			type: "int256[]",
+			internalType: "int256[]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "isAccountSolvent",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "account",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]",
+				internalType: "TokenId[]"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			}
+		],
+		outputs: [{
+			name: "",
+			type: "bool",
+			internalType: "bool"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "optimizeRiskPartners",
+		inputs: [
+			{
+				name: "pool",
+				type: "address",
+				internalType: "contract PanopticPool"
+			},
+			{
+				name: "atTick",
+				type: "int24",
+				internalType: "int24"
+			},
+			{
+				name: "tokenId",
+				type: "uint256",
+				internalType: "TokenId"
+			}
+		],
+		outputs: [{
+			name: "",
+			type: "uint256",
+			internalType: "TokenId"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "twapFilter",
+		inputs: [{
+			name: "univ3pool",
+			type: "address",
+			internalType: "contract IUniswapV3Pool"
+		}, {
+			name: "twapWindow",
+			type: "uint32",
+			internalType: "uint32"
+		}],
+		outputs: [{
+			name: "",
+			type: "int24",
+			internalType: "int24"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "validateTokenId",
+		inputs: [{
+			name: "self",
+			type: "uint256",
+			internalType: "TokenId"
+		}],
+		outputs: [],
+		stateMutability: "pure"
+	},
+	{
+		type: "error",
+		name: "CastingError",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidTick",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidTokenIdParameter",
+		inputs: [{
+			name: "parameterType",
+			type: "uint256",
+			internalType: "uint256"
+		}]
+	},
+	{
+		type: "error",
+		name: "LiquidityTooHigh",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "UnderOverFlow",
+		inputs: []
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/reads/multicallBlock.ts
+const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+function hasCall(client) {
+	return "call" in client && typeof client.call === "function";
+}
+function requireResult(results, index, label) {
+	const result = results[index];
+	if (result === void 0) throw new MulticallResultMissingError(label, index);
+	if (!result.success) throw new MulticallResultFailedError(label, index);
+	return result;
+}
+function requireReturnData(results, index, label) {
+	return requireResult(results, index, label).returnData;
+}
+async function readBlockAndAggregate({ client, calls, blockNumber }) {
+	const aggregateCalls = [...calls, {
+		target: MULTICALL3_ADDRESS,
+		callData: encodeFunctionData({
+			abi: Multicall3Abi,
+			functionName: "getCurrentBlockTimestamp"
+		})
+	}];
+	const data = encodeFunctionData({
+		abi: Multicall3Abi,
+		functionName: "blockAndAggregate",
+		args: [aggregateCalls]
+	});
+	const parameters = {
+		to: MULTICALL3_ADDRESS,
+		data,
+		blockNumber
+	};
+	const response = hasCall(client) ? await client.call(parameters) : await call(client, parameters);
+	if (response.data === void 0) throw new MulticallNoDataError("blockAndAggregate");
+	const aggregateResult = decodeFunctionResult({
+		abi: Multicall3Abi,
+		functionName: "blockAndAggregate",
+		data: response.data
+	});
+	const [aggregateBlockNumber, blockHash, rawResults] = aggregateResult;
+	const timestampResult = requireReturnData(rawResults, calls.length, "Multicall3.getCurrentBlockTimestamp");
+	const blockTimestamp = decodeFunctionResult({
+		abi: Multicall3Abi,
+		functionName: "getCurrentBlockTimestamp",
+		data: timestampResult
+	});
+	return {
+		_meta: {
+			blockNumber: aggregateBlockNumber,
+			blockHash,
+			blockTimestamp
+		},
+		results: rawResults.slice(0, calls.length)
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/checks.ts
+const FP96 = 1n << 96n;
+const Q128 = 1n << 128n;
+function convert0to1(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * sp2Hi >> 128n;
+}
+function convert1to0(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128) {
+		const denom = sqrtPriceX96 * sqrtPriceX96;
+		return amount * (1n << 192n) / denom;
+	}
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * (1n << 128n) / sp2Hi;
+}
+/**
+* Check if an account is liquidatable with detailed margin breakdown.
+*
+* Sources gross collateral from `CollateralTracker.assetsOf` and per-position
+* required margin from `PanopticPool.getFullPositionsData.collateralRequirements[]`,
+* cross-converted to each token denomination at `atTick`. Loan tokenIds
+* (width=0 shorts) contribute correctly to required margin.
+*
+* @param params - The parameters
+* @returns Liquidation check result with detailed margin breakdown
+*
+* @example
+* ```typescript
+* const result = await isLiquidatable({
+*   client,
+*   poolAddress,
+*   account,
+*   tokenIds: [position1, position2],
+* })
+*
+* if (result.isLiquidatable) {
+*   console.log('Account is liquidatable!')
+* }
+* ```
+*/
+async function isLiquidatable(params) {
+	const { client, poolAddress, account, tokenIds, atTick, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	let collateralToken0;
+	let collateralToken1;
+	if (params.collateralAddresses) {
+		collateralToken0 = params.collateralAddresses.collateralToken0;
+		collateralToken1 = params.collateralAddresses.collateralToken1;
+	} else {
+		const addrs = await client.multicall({
+			contracts: [{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken0"
+			}, {
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken1"
+			}],
+			blockNumber: targetBlockNumber,
+			allowFailure: false
+		});
+		collateralToken0 = addrs[0];
+		collateralToken1 = addrs[1];
+	}
+	const calls = [];
+	const currentTickIndex = atTick === void 0 ? calls.length : null;
+	if (currentTickIndex !== null) calls.push({
+		target: poolAddress,
+		callData: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getCurrentTick"
+		})
+	});
+	const assets0Index = calls.length;
+	calls.push({
+		target: collateralToken0,
+		callData: encodeFunctionData({
+			abi: collateralTrackerV2Abi,
+			functionName: "assetsOf",
+			args: [account]
+		})
+	});
+	const assets1Index = calls.length;
+	calls.push({
+		target: collateralToken1,
+		callData: encodeFunctionData({
+			abi: collateralTrackerV2Abi,
+			functionName: "assetsOf",
+			args: [account]
+		})
+	});
+	const positionDataIndex = tokenIds.length > 0 ? calls.length : null;
+	if (positionDataIndex !== null) calls.push({
+		target: poolAddress,
+		callData: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				true,
+				tokenIds
+			]
+		})
+	});
+	const { _meta, results } = await readBlockAndAggregate({
+		client,
+		calls,
+		blockNumber: targetBlockNumber
+	});
+	let effectiveTick = atTick;
+	if (effectiveTick === void 0) {
+		if (currentTickIndex === null) throw new Error("Missing current tick Multicall3 result index");
+		effectiveTick = BigInt(decodeFunctionResult({
+			abi: panopticPoolV2Abi,
+			functionName: "getCurrentTick",
+			data: requireReturnData(results, currentTickIndex, "PanopticPool.getCurrentTick")
+		}));
+	}
+	const assets0 = decodeFunctionResult({
+		abi: collateralTrackerV2Abi,
+		functionName: "assetsOf",
+		data: requireReturnData(results, assets0Index, "CollateralTracker.assetsOf token0")
+	});
+	const assets1 = decodeFunctionResult({
+		abi: collateralTrackerV2Abi,
+		functionName: "assetsOf",
+		data: requireReturnData(results, assets1Index, "CollateralTracker.assetsOf token1")
+	});
+	const positionDataResult = positionDataIndex === null ? null : decodeFunctionResult({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		data: requireReturnData(results, positionDataIndex, "PanopticPool.getFullPositionsData")
+	});
+	let required0Native = 0n;
+	let required1Native = 0n;
+	if (positionDataResult) {
+		const collateralRequirements = positionDataResult[3];
+		for (const packed of collateralRequirements) {
+			const decoded = decodeLeftRightUnsigned(packed);
+			required0Native += decoded.right;
+			required1Native += decoded.left;
+		}
+	}
+	const sqrtPriceX96 = tickToSqrtPriceX96(effectiveTick);
+	const currentMargin0 = assets0 + convert1to0(assets1, sqrtPriceX96);
+	const requiredMargin0 = required0Native + convert1to0(required1Native, sqrtPriceX96);
+	const currentMargin1 = assets1 + convert0to1(assets0, sqrtPriceX96);
+	const requiredMargin1 = required1Native + convert0to1(required0Native, sqrtPriceX96);
+	const marginShortfall0 = requiredMargin0 - currentMargin0;
+	const marginShortfall1 = requiredMargin1 - currentMargin1;
+	const denominatedInToken = sqrtPriceX96 < FP96 ? 0n : 1n;
+	const isLiquidatableResult = denominatedInToken === 0n ? marginShortfall0 > 0n : marginShortfall1 > 0n;
+	return {
+		isLiquidatable: isLiquidatableResult,
+		marginShortfall0,
+		marginShortfall1,
+		currentMargin0,
+		currentMargin1,
+		requiredMargin0,
+		requiredMargin1,
+		denominatedInToken,
+		atTick: effectiveTick,
+		_meta
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/account.ts
+/**
+* Extract collateral tracker addresses from a Pool object.
+*
+* Convenience helper that avoids re-fetching immutable addresses
+* when you already have a Pool from a prior `getPool()` call.
+*
+* @param pool - Pool object from getPool()
+* @returns Collateral tracker addresses
+*/
+function getCollateralAddresses(pool) {
+	return {
+		collateralToken0: pool.collateralTracker0.address,
+		collateralToken1: pool.collateralTracker1.address
+	};
+}
+/**
+* Get collateral data for an account.
+*
+* ## Same-Block Guarantee
+* All dynamic data is fetched in ONE multicall at the target block.
+* Collateral tracker addresses are either provided or fetched separately (static prefetch).
+*
+* @param params - The parameters
+* @returns Account collateral data with block metadata
+*/
+async function getAccountCollateral(params) {
+	const { client, poolAddress, account, blockNumber, collateralAddresses } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	let collateralToken0;
+	let collateralToken1;
+	if (collateralAddresses) {
+		collateralToken0 = collateralAddresses.collateralToken0;
+		collateralToken1 = collateralAddresses.collateralToken1;
+	} else {
+		const addressResults = await client.multicall({
+			contracts: [{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken0"
+			}, {
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken1"
+			}],
+			allowFailure: false
+		});
+		collateralToken0 = addressResults[0];
+		collateralToken1 = addressResults[1];
+	}
+	const [dynamicResults, _meta] = await Promise.all([client.multicall({
+		contracts: [
+			{
+				address: collateralToken0,
+				abi: collateralTrackerV2Abi,
+				functionName: "balanceOf",
+				args: [account]
+			},
+			{
+				address: collateralToken0,
+				abi: collateralTrackerV2Abi,
+				functionName: "assetsOf",
+				args: [account]
+			},
+			{
+				address: collateralToken0,
+				abi: collateralTrackerV2Abi,
+				functionName: "maxWithdraw",
+				args: [account]
+			},
+			{
+				address: collateralToken1,
+				abi: collateralTrackerV2Abi,
+				functionName: "balanceOf",
+				args: [account]
+			},
+			{
+				address: collateralToken1,
+				abi: collateralTrackerV2Abi,
+				functionName: "assetsOf",
+				args: [account]
+			},
+			{
+				address: collateralToken1,
+				abi: collateralTrackerV2Abi,
+				functionName: "maxWithdraw",
+				args: [account]
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "numberOfLegs",
+				args: [account]
+			}
+		],
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [shares0, assets0, maxWithdraw0, shares1, assets1, maxWithdraw1, legCount] = dynamicResults;
+	const locked0 = assets0 > maxWithdraw0 ? assets0 - maxWithdraw0 : 0n;
+	const locked1 = assets1 > maxWithdraw1 ? assets1 - maxWithdraw1 : 0n;
+	const token0 = {
+		assets: assets0,
+		shares: shares0,
+		availableAssets: maxWithdraw0,
+		lockedAssets: locked0
+	};
+	const token1 = {
+		assets: assets1,
+		shares: shares1,
+		availableAssets: maxWithdraw1,
+		lockedAssets: locked1
+	};
+	return {
+		account,
+		poolAddress,
+		token0,
+		token1,
+		legCount,
+		_meta
+	};
+}
+async function getAccountSummaryCore(params) {
+	const { client, poolAddress, account, chainId, tokenIds, blockNumber, poolMetadata } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const sharedMeta = params._meta ?? await getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	});
+	const collateralAddresses = poolMetadata ? {
+		collateralToken0: poolMetadata.collateralToken0Address,
+		collateralToken1: poolMetadata.collateralToken1Address
+	} : void 0;
+	const [pool, collateral, { positions }] = await Promise.all([
+		getPool({
+			client,
+			poolAddress,
+			chainId,
+			blockNumber: targetBlockNumber,
+			poolMetadata,
+			_meta: sharedMeta
+		}),
+		getAccountCollateral({
+			client,
+			poolAddress,
+			account,
+			blockNumber: targetBlockNumber,
+			collateralAddresses,
+			_meta: sharedMeta
+		}),
+		getPositions({
+			client,
+			poolAddress,
+			owner: account,
+			tokenIds,
+			blockNumber: targetBlockNumber,
+			_meta: sharedMeta
+		})
+	]);
+	return {
+		pool,
+		collateral,
+		positions,
+		_meta: sharedMeta
+	};
+}
+/**
+* Get base account summary data for UI dashboards.
+*
+* ## Same-Block Guarantee
+* Uses the same blockNumber for pool, collateral, and position reads.
+*
+* @param params - The parameters
+* @returns Base account summary with block metadata
+*/
+async function getAccountSummaryBasic(params) {
+	const { account } = params;
+	const { pool, collateral, positions, _meta } = await getAccountSummaryCore(params);
+	return {
+		account,
+		pool,
+		collateral,
+		positions,
+		healthStatus: pool.healthStatus,
+		networkMismatch: false,
+		_meta
+	};
+}
+/**
+* Get risk-focused account summary including helper-dependent fields.
+*
+* ## Same-Block Guarantee
+* Uses one block target for all pool/collateral/position/risk reads.
+*
+* @param params - The parameters
+* @returns Risk-focused account summary with block metadata
+*/
+async function getAccountSummaryRisk(params) {
+	const { client, poolAddress, account, tokenIds, queryAddress, atTick, includePendingPremium = true, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const sharedMeta = params._meta ?? await getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	});
+	const [{ pool, collateral, positions }, nlv, liquidationCheck, liquidationPrices] = await Promise.all([
+		getAccountSummaryCore({
+			...params,
+			blockNumber: targetBlockNumber,
+			_meta: sharedMeta
+		}),
+		getNetLiquidationValue({
+			client,
+			poolAddress,
+			account,
+			tokenIds,
+			atTick,
+			includePendingPremium,
+			queryAddress,
+			blockNumber: targetBlockNumber,
+			_meta: sharedMeta
+		}),
+		isLiquidatable({
+			client,
+			poolAddress,
+			account,
+			tokenIds,
+			atTick,
+			queryAddress,
+			blockNumber: targetBlockNumber,
+			_meta: sharedMeta
+		}),
+		getLiquidationPrices({
+			client,
+			poolAddress,
+			account,
+			tokenIds,
+			queryAddress,
+			blockNumber: targetBlockNumber,
+			_meta: sharedMeta
+		})
+	]);
+	const totalGreeks = {
+		value: 0n,
+		delta: 0n,
+		gamma: 0n
+	};
+	const maintenanceMargin0 = liquidationCheck.requiredMargin0;
+	const maintenanceMargin1 = liquidationCheck.requiredMargin1;
+	const marginExcess0 = liquidationCheck.currentMargin0 - liquidationCheck.requiredMargin0;
+	const marginExcess1 = liquidationCheck.currentMargin1 - liquidationCheck.requiredMargin1;
+	return {
+		account,
+		pool,
+		collateral,
+		positions,
+		totalGreeks,
+		netLiquidationValue0: nlv.value0,
+		netLiquidationValue1: nlv.value1,
+		maintenanceMargin0,
+		maintenanceMargin1,
+		marginExcess0,
+		marginExcess1,
+		marginShortfall0: liquidationCheck.marginShortfall0,
+		marginShortfall1: liquidationCheck.marginShortfall1,
+		currentMargin0: liquidationCheck.currentMargin0,
+		currentMargin1: liquidationCheck.currentMargin1,
+		isLiquidatable: liquidationCheck.isLiquidatable,
+		liquidationPrices,
+		healthStatus: pool.healthStatus,
+		networkMismatch: false,
+		_meta: sharedMeta
+	};
+}
+/**
+* Get net liquidation value for an account.
+*
+* ## Same-Block Guarantee
+* Tick and NLV are queried at the same target block.
+*
+* Requires PanopticQuery for accurate value and premium accounting.
+*
+* @param params - The parameters
+* @returns Net liquidation value with block metadata
+*/
+async function getNetLiquidationValue(params) {
+	const { client, poolAddress, account, tokenIds, atTick, includePendingPremium = true, queryAddress, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const [currentTickResult, _meta] = await Promise.all([atTick != null ? Promise.resolve(atTick) : client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getCurrentTick",
+		blockNumber: targetBlockNumber
+	}).then((r) => BigInt(r)), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const effectiveTick = currentTickResult;
+	const result = await client.readContract({
+		address: queryAddress,
+		abi: panopticQueryAbi,
+		functionName: "getNetLiquidationValue",
+		args: [
+			poolAddress,
+			account,
+			includePendingPremium,
+			tokenIds,
+			Number(effectiveTick)
+		],
+		blockNumber: targetBlockNumber
+	});
+	const [value0, value1] = result;
+	return {
+		value0,
+		value1,
+		atTick: effectiveTick,
+		includedPendingPremium: includePendingPremium,
+		_meta
+	};
+}
+/**
+* Get net liquidation values at multiple ticks in a single contract call.
+*
+* Uses the `int24[]` overload of `getNetLiquidationValue` on PanopticQuery.
+*
+* @param params - The parameters
+* @returns Net liquidation values with block metadata
+*/
+async function getNetLiquidationValues(params) {
+	const { client, poolAddress, account, tokenIds, atTicks, includePendingPremium = true, queryAddress, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const batchNlvAbi = [{
+		type: "function",
+		name: "getNetLiquidationValue",
+		inputs: [
+			{
+				name: "pool",
+				type: "address"
+			},
+			{
+				name: "account",
+				type: "address"
+			},
+			{
+				name: "includePendingPremium",
+				type: "bool"
+			},
+			{
+				name: "positionIdList",
+				type: "uint256[]"
+			},
+			{
+				name: "atTicks",
+				type: "int24[]"
+			}
+		],
+		outputs: [{
+			name: "value0",
+			type: "int256[]"
+		}, {
+			name: "value1",
+			type: "int256[]"
+		}],
+		stateMutability: "view"
+	}];
+	const [result, _meta] = await Promise.all([client.readContract({
+		address: queryAddress,
+		abi: batchNlvAbi,
+		functionName: "getNetLiquidationValue",
+		args: [
+			poolAddress,
+			account,
+			includePendingPremium,
+			tokenIds,
+			atTicks.map((t) => Number(t))
+		],
+		blockNumber: targetBlockNumber
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [values0, values1] = result;
+	return {
+		values0: [...values0],
+		values1: [...values1],
+		atTicks,
+		_meta
+	};
+}
+/**
+* Get liquidation prices for an account.
+*
+* ## Same-Block Guarantee
+* Liquidation price query is made at a single block.
+*
+* @param params - The parameters
+* @returns Liquidation prices with block metadata
+*/
+async function getLiquidationPrices(params) {
+	const { client, poolAddress, account, tokenIds, queryAddress, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const MIN_TICK = -887272n;
+	const MAX_TICK = 887272n;
+	const [result, _meta] = await Promise.all([client.readContract({
+		address: queryAddress,
+		abi: panopticQueryAbi,
+		functionName: "getLiquidationPrices",
+		args: [
+			poolAddress,
+			account,
+			tokenIds
+		],
+		blockNumber: targetBlockNumber
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const liqPriceDown = BigInt(result[0]);
+	const liqPriceUp = BigInt(result[1]);
+	return {
+		lowerTick: liqPriceDown === MIN_TICK ? null : liqPriceDown,
+		upperTick: liqPriceUp === MAX_TICK ? null : liqPriceUp,
+		isLiquidatable: liqPriceDown !== MIN_TICK || liqPriceUp !== MAX_TICK,
+		_meta
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/collateral.ts
+const SECONDS_PER_YEAR$2 = 31536000n;
+const erc20Abi$1 = [{
+	type: "function",
+	name: "symbol",
+	inputs: [],
+	outputs: [{ type: "string" }],
+	stateMutability: "view"
+}, {
+	type: "function",
+	name: "decimals",
+	inputs: [],
+	outputs: [{ type: "uint8" }],
+	stateMutability: "view"
+}];
+/**
+* Get collateral tracker data for a specific token.
+*
+* ## Same-Block Guarantee
+* All dynamic data is fetched in ONE multicall at the target block.
+* Static metadata (address, symbol, decimals) is either provided or fetched separately.
+*
+* @param params - The parameters
+* @returns Collateral tracker data with block metadata
+*/
+async function getCollateralData(params) {
+	const { client, poolAddress, tokenIndex, blockNumber, trackerMetadata } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (trackerMetadata) {
+		const [dynamicResults, _meta$1] = await Promise.all([client.multicall({
+			contracts: [
+				{
+					address: trackerMetadata.address,
+					abi: collateralTrackerV2Abi,
+					functionName: "getPoolData"
+				},
+				{
+					address: trackerMetadata.address,
+					abi: collateralTrackerV2Abi,
+					functionName: "totalSupply"
+				},
+				{
+					address: trackerMetadata.address,
+					abi: collateralTrackerV2Abi,
+					functionName: "interestRate"
+				}
+			],
+			blockNumber: targetBlockNumber,
+			allowFailure: false
+		}), params._meta ?? getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		})]);
+		const [poolData$1, totalShares$1, interestRate$1] = dynamicResults;
+		const [depositedAssets$1, insideAMM$1, creditedShares$1, utilization$1] = poolData$1;
+		const totalAssets$1 = depositedAssets$1 + insideAMM$1;
+		const borrowRate$1 = BigInt(interestRate$1) * SECONDS_PER_YEAR$2;
+		const supplyRate$1 = borrowRate$1 * utilization$1 / 10000n;
+		return {
+			address: trackerMetadata.address,
+			token: trackerMetadata.assetAddress,
+			symbol: trackerMetadata.symbol,
+			decimals: trackerMetadata.decimals,
+			totalAssets: totalAssets$1,
+			insideAMM: insideAMM$1,
+			creditedShares: creditedShares$1,
+			totalShares: totalShares$1,
+			utilization: utilization$1,
+			borrowRate: borrowRate$1,
+			supplyRate: supplyRate$1,
+			_meta: _meta$1
+		};
+	}
+	const collateralTrackerAddress = await client.readContract({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: tokenIndex === 0 ? "collateralToken0" : "collateralToken1"
+	});
+	const [trackerData, _meta] = await Promise.all([client.multicall({
+		contracts: [
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "asset"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "totalSupply"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "interestRate"
+			}
+		],
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [assetAddress, poolData, totalShares, interestRate] = trackerData;
+	const [symbol, decimals] = await client.multicall({
+		contracts: [{
+			address: assetAddress,
+			abi: erc20Abi$1,
+			functionName: "symbol"
+		}, {
+			address: assetAddress,
+			abi: erc20Abi$1,
+			functionName: "decimals"
+		}],
+		allowFailure: false
+	});
+	const [depositedAssets, insideAMM, creditedShares, utilization] = poolData;
+	const totalAssets = depositedAssets + insideAMM;
+	const borrowRate = BigInt(interestRate) * SECONDS_PER_YEAR$2;
+	const supplyRate = borrowRate * utilization / 10000n;
+	return {
+		address: collateralTrackerAddress,
+		token: assetAddress,
+		symbol,
+		decimals: BigInt(decimals),
+		totalAssets,
+		insideAMM,
+		creditedShares,
+		totalShares,
+		utilization,
+		borrowRate,
+		supplyRate,
+		_meta
+	};
+}
+/**
+* Get current interest rates for both tokens.
+*
+* ## Same-Block Guarantee
+* All dynamic data is fetched in ONE multicall at the target block.
+* Collateral tracker addresses are either provided or fetched separately (static prefetch).
+*
+* @param params - The parameters
+* @returns Current rates with block metadata
+*/
+async function getCurrentRates(params) {
+	const { client, poolAddress, blockNumber, collateralAddresses } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	let collateralToken0;
+	let collateralToken1;
+	if (collateralAddresses) {
+		collateralToken0 = collateralAddresses.collateralToken0;
+		collateralToken1 = collateralAddresses.collateralToken1;
+	} else {
+		const addressResults = await client.multicall({
+			contracts: [{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken0"
+			}, {
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken1"
+			}],
+			allowFailure: false
+		});
+		collateralToken0 = addressResults[0];
+		collateralToken1 = addressResults[1];
+	}
+	const [rateData, _meta] = await Promise.all([client.multicall({
+		contracts: [
+			{
+				address: collateralToken0,
+				abi: collateralTrackerV2Abi,
+				functionName: "interestRate"
+			},
+			{
+				address: collateralToken0,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			},
+			{
+				address: collateralToken1,
+				abi: collateralTrackerV2Abi,
+				functionName: "interestRate"
+			},
+			{
+				address: collateralToken1,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			}
+		],
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [interestRate0, poolData0, interestRate1, poolData1] = rateData;
+	const utilization0 = poolData0[3];
+	const utilization1 = poolData1[3];
+	const borrowRate0 = BigInt(interestRate0) * SECONDS_PER_YEAR$2;
+	const borrowRate1 = BigInt(interestRate1) * SECONDS_PER_YEAR$2;
+	const supplyRate0 = borrowRate0 * utilization0 / 10000n;
+	const supplyRate1 = borrowRate1 * utilization1 / 10000n;
+	return {
+		borrowRate0,
+		supplyRate0,
+		borrowRate1,
+		supplyRate1,
+		_meta
+	};
+}
+/**
+* Get per-user interest state (borrow index + net borrows) for both tokens.
+*
+* Calls `collateralTracker.interestState(user)` on both trackers in a single multicall.
+*
+* @param params - The parameters
+* @returns Interest state for both tokens with block metadata
+*/
+async function getInterestState(params) {
+	const { client, poolAddress, account, blockNumber, collateralAddresses } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	let collateralToken0;
+	let collateralToken1;
+	if (collateralAddresses) {
+		collateralToken0 = collateralAddresses.collateralToken0;
+		collateralToken1 = collateralAddresses.collateralToken1;
+	} else {
+		const addressResults = await client.multicall({
+			contracts: [{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken0"
+			}, {
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken1"
+			}],
+			allowFailure: false
+		});
+		collateralToken0 = addressResults[0];
+		collateralToken1 = addressResults[1];
+	}
+	const [results, _meta] = await Promise.all([client.multicall({
+		contracts: [{
+			address: collateralToken0,
+			abi: collateralTrackerV2Abi,
+			functionName: "interestState",
+			args: [account]
+		}, {
+			address: collateralToken1,
+			abi: collateralTrackerV2Abi,
+			functionName: "interestState",
+			args: [account]
+		}],
+		blockNumber: targetBlockNumber,
+		allowFailure: false
+	}), params._meta ?? getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const [state0, state1] = results;
+	return {
+		token0: {
+			userBorrowIndex: state0[0],
+			netBorrows: state0[1]
+		},
+		token1: {
+			userBorrowIndex: state1[0],
+			netBorrows: state1[1]
+		},
+		_meta
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/formatters/amount.ts
+/**
+* Format a raw token amount to a human-readable string.
+*
+* @param amount - The amount in smallest units (e.g., wei)
+* @param decimals - Token decimals (e.g., 18n for WETH, 6n for USDC)
+* @param precision - Number of decimal places to display
+* @returns Formatted string
+*
+* @example
+* ```typescript
+* formatTokenAmount(1500000000000000000n, 18n, 4n) // "1.5000"
+* formatTokenAmount(1500000000000000000n, 18n, 2n) // "1.50"
+* formatTokenAmount(1500000n, 6n, 2n)              // "1.50" (USDC)
+* formatTokenAmount(-500000000000000000n, 18n, 4n) // "-0.5000"
+* ```
+*/
+function formatTokenAmount(amount, decimals, precision) {
+	const isNegative = amount < 0n;
+	const absAmount = isNegative ? -amount : amount;
+	const divisor = 10n ** decimals;
+	const integerPart = absAmount / divisor;
+	const fractionalPart = absAmount % divisor;
+	const fullFractionalStr = fractionalPart.toString().padStart(Number(decimals), "0");
+	const truncatedFractionalStr = fullFractionalStr.slice(0, Number(precision));
+	const paddedFractionalStr = truncatedFractionalStr.padEnd(Number(precision), "0");
+	const sign = isNegative ? "-" : "";
+	return precision > 0n ? `${sign}${integerPart}.${paddedFractionalStr}` : `${sign}${integerPart}`;
+}
+/**
+* Format a token amount with a sign prefix (+/-) for non-zero values.
+* Useful for displaying PnL, deltas, or changes.
+*
+* @param amount - The amount in smallest units
+* @param decimals - Token decimals
+* @param precision - Number of decimal places to display
+* @returns Formatted string with sign prefix
+*
+* @example
+* ```typescript
+* formatTokenAmountSigned(1500000000000000000n, 18n, 4n)  // "+1.5000"
+* formatTokenAmountSigned(-500000000000000000n, 18n, 4n) // "-0.5000"
+* formatTokenAmountSigned(0n, 18n, 4n)                   // "0.0000"
+* ```
+*/
+function formatTokenAmountSigned(amount, decimals, precision) {
+	const formatted = formatTokenAmount(amount, decimals, precision);
+	if (amount > 0n) return `+${formatted}`;
+	return formatted;
+}
+/**
+* Parse a human-readable token amount string to raw units.
+*
+* @param amount - Human-readable amount string (e.g., "1.5")
+* @param decimals - Token decimals
+* @returns Amount in smallest units
+*
+* @example
+* ```typescript
+* parseTokenAmount("1.5", 18n)   // 1500000000000000000n
+* parseTokenAmount("1.5", 6n)    // 1500000n (USDC)
+* parseTokenAmount("100", 18n)   // 100000000000000000000n
+* parseTokenAmount("-0.5", 18n)  // -500000000000000000n
+* ```
+*/
+function parseTokenAmount(amount, decimals) {
+	const trimmed = amount.trim();
+	const isNegative = trimmed.startsWith("-");
+	const cleanAmount = isNegative ? trimmed.slice(1) : trimmed;
+	const [integerStr, fractionalStr = ""] = cleanAmount.split(".");
+	const paddedFractional = fractionalStr.padEnd(Number(decimals), "0").slice(0, Number(decimals));
+	const integerPart = BigInt(integerStr || "0") * 10n ** decimals;
+	const fractionalPart = BigInt(paddedFractional || "0");
+	const result = integerPart + fractionalPart;
+	return isNegative ? -result : result;
+}
+/**
+* Format a token delta amount with a sign prefix (+/-) for non-zero values.
+* Alias for formatTokenAmountSigned, useful for clarity at call sites.
+*
+* @param amount - The delta amount in smallest units
+* @param decimals - Token decimals
+* @param precision - Number of decimal places to display
+* @returns Formatted string with sign prefix
+*/
+function formatTokenDelta(amount, decimals, precision) {
+	return formatTokenAmountSigned(amount, decimals, precision);
+}
+/**
+* Format token flow deltas and balances from simulation results.
+*
+* @param flow - Token flow data
+* @param decimals0 - Token0 decimals
+* @param decimals1 - Token1 decimals
+* @param precision0 - Precision for token0 formatting
+* @param precision1 - Precision for token1 formatting
+* @returns Formatted token flow strings
+*/
+function formatTokenFlow(flow, decimals0, decimals1, precision0, precision1) {
+	return {
+		delta0: formatTokenAmountSigned(flow.delta0, decimals0, precision0),
+		delta1: formatTokenAmountSigned(flow.delta1, decimals1, precision1),
+		balanceBefore0: formatTokenAmount(flow.balanceBefore0, decimals0, precision0),
+		balanceBefore1: formatTokenAmount(flow.balanceBefore1, decimals1, precision1),
+		balanceAfter0: formatTokenAmount(flow.balanceAfter0, decimals0, precision0),
+		balanceAfter1: formatTokenAmount(flow.balanceAfter1, decimals1, precision1)
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/formatters/wad.ts
+/**
+* Format a WAD-scaled value (1e18 = 1.0).
+*
+* @param wad - WAD-scaled value
+* @param precision - Number of decimal places to display
+* @returns Formatted string
+*
+* @example
+* ```typescript
+* formatWad(1220000000000000000n, 2n) // "1.22"
+* formatWad(1220000000000000000n, 4n) // "1.2200"
+* formatWad(1000000000000000000n, 2n) // "1.00"
+* formatWad(500000000000000000n, 2n)  // "0.50"
+* ```
+*/
+function formatWad(wad, precision) {
+	return formatTokenAmount(wad, 18n, precision);
+}
+/**
+* Format a WAD-scaled value with sign prefix (+/-) for non-zero values.
+*
+* @param wad - WAD-scaled value
+* @param precision - Number of decimal places to display
+* @returns Formatted string with sign prefix
+*
+* @example
+* ```typescript
+* formatWadSigned(1220000000000000000n, 2n)  // "+1.22"
+* formatWadSigned(-500000000000000000n, 2n) // "-0.50"
+* formatWadSigned(0n, 2n)                   // "0.00"
+* ```
+*/
+function formatWadSigned(wad, precision) {
+	const formatted = formatWad(wad, precision);
+	if (wad > 0n) return `+${formatted}`;
+	return formatted;
+}
+/**
+* Format a WAD-scaled value as a percentage string.
+*
+* @param wad - WAD-scaled value
+* @param precision - Number of decimal places to display
+* @returns Formatted percentage string
+*
+* @example
+* ```typescript
+* formatWadPercent(50000000000000000n, 2n) // "5.00%"
+* formatWadPercent(1000000000000000000n, 1n) // "100.0%"
+* ```
+*/
+function formatWadPercent(wad, precision) {
+	return `${formatTokenAmount(wad * 100n, 18n, precision)}%`;
+}
+/**
+* Format an annualized rate stored as a WAD-scaled value.
+* Alias for formatWadPercent.
+*
+* @param rateWad - Rate in WAD (1e18 = 1.0)
+* @param precision - Number of decimal places to display
+* @returns Formatted percentage string
+*/
+function formatRateWad(rateWad, precision) {
+	return formatWadPercent(rateWad, precision);
+}
+/**
+* Parse a decimal string to a WAD-scaled value.
+*
+* @param value - Decimal string (e.g., "1.5")
+* @returns WAD-scaled bigint
+*
+* @example
+* ```typescript
+* parseWad("1.5")   // 1500000000000000000n
+* parseWad("0.5")   // 500000000000000000n
+* parseWad("100")   // 100000000000000000000n
+* parseWad("-1.22") // -1220000000000000000n
+* ```
+*/
+function parseWad(value) {
+	const trimmed = value.trim();
+	const isNegative = trimmed.startsWith("-");
+	const cleanValue = isNegative ? trimmed.slice(1) : trimmed;
+	const [integerStr, fractionalStr = ""] = cleanValue.split(".");
+	const paddedFractional = fractionalStr.padEnd(18, "0").slice(0, 18);
+	const integerPart = BigInt(integerStr || "0") * 10n ** 18n;
+	const fractionalPart = BigInt(paddedFractional || "0");
+	const result = integerPart + fractionalPart;
+	return isNegative ? -result : result;
+}
+
+//#endregion
+//#region src/panoptic/v2/formatters/rates.ts
+const SECONDS_PER_DAY = 86400n;
+const DAYS_PER_YEAR = 365n;
+const SECONDS_PER_YEAR$1 = SECONDS_PER_DAY * DAYS_PER_YEAR;
+/**
+* Annualize a per-second WAD-scaled rate to annual WAD.
+*
+* @param ratePerSecondWad - Rate in WAD per second
+* @returns Annualized rate in WAD
+*/
+function annualizePerSecondRateWad(ratePerSecondWad) {
+	return ratePerSecondWad * SECONDS_PER_YEAR$1;
+}
+/**
+* Format a per-second WAD rate as APY percentage text.
+* Uses linear annualization, then formats as WAD percent.
+*
+* @param ratePerSecondWad - Rate in WAD per second
+* @param precision - Decimal places
+* @returns Percentage string, e.g. "2.41%"
+*/
+function formatPerSecondRateWadAsApyPct(ratePerSecondWad, precision) {
+	return formatWadPercent(annualizePerSecondRateWad(ratePerSecondWad), precision);
+}
+/**
+* Format a per-second WAD rate as APR percentage text.
+* For this rate model, APR presentation uses the same annualized output.
+*
+* @param ratePerSecondWad - Rate in WAD per second
+* @param precision - Decimal places
+* @returns Percentage string, e.g. "2.41%"
+*/
+function formatPerSecondRateWadAsAprPct(ratePerSecondWad, precision) {
+	return formatWadPercent(annualizePerSecondRateWad(ratePerSecondWad), precision);
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/irm.ts
+const WAD = 10n ** 18n;
+const BPS_SCALE = 10000n;
+const SECONDS_PER_YEAR = 31536000n;
+const MARKET_EPOCH_SHIFT = 2n;
+const BORROW_INDEX_BITS = 80n;
+const MARKET_EPOCH_BITS = 32n;
+const RATE_AT_TARGET_BITS = 38n;
+const UNREALIZED_INTEREST_BITS = 106n;
+const BORROW_INDEX_SHIFT = 0n;
+const MARKET_EPOCH_FIELD_SHIFT = BORROW_INDEX_BITS;
+const RATE_AT_TARGET_FIELD_SHIFT = BORROW_INDEX_BITS + MARKET_EPOCH_BITS;
+const UNREALIZED_INTEREST_FIELD_SHIFT = RATE_AT_TARGET_FIELD_SHIFT + RATE_AT_TARGET_BITS;
+const MAX_IRM_CURVE_POINTS = 500;
+const clampUtilizationBps = (utilizationBps) => {
+	if (utilizationBps < 0n) return 0n;
+	if (utilizationBps > BPS_SCALE) return BPS_SCALE;
+	return utilizationBps;
+};
+const getMaxValue = (bits) => (1n << bits) - 1n;
+const assertFitsBits = (value, bits, fieldName) => {
+	if (value < 0n) throw new PanopticValidationError(`${fieldName} must be >= 0`);
+	if (value > getMaxValue(bits)) throw new PanopticValidationError(`${fieldName} exceeds ${bits.toString()} bits`);
+};
+function packMarketState(inputs) {
+	const { borrowIndex, lastInteractionTimestamp, rateAtTarget, unrealizedGlobalInterest } = inputs;
+	const marketEpoch = lastInteractionTimestamp >> MARKET_EPOCH_SHIFT;
+	assertFitsBits(borrowIndex, BORROW_INDEX_BITS, "borrowIndex");
+	assertFitsBits(marketEpoch, MARKET_EPOCH_BITS, "marketEpoch");
+	assertFitsBits(rateAtTarget, RATE_AT_TARGET_BITS, "rateAtTarget");
+	assertFitsBits(unrealizedGlobalInterest, UNREALIZED_INTEREST_BITS, "unrealizedGlobalInterest");
+	return (borrowIndex << BORROW_INDEX_SHIFT) + (marketEpoch << MARKET_EPOCH_FIELD_SHIFT) + (rateAtTarget << RATE_AT_TARGET_FIELD_SHIFT) + (unrealizedGlobalInterest << UNREALIZED_INTEREST_FIELD_SHIFT);
+}
+function utilizationPctToWad(utilizationPct) {
+	if (!Number.isFinite(utilizationPct)) throw new PanopticValidationError("utilizationPct must be finite");
+	if (utilizationPct < 0 || utilizationPct > 100) throw new PanopticValidationError("utilizationPct must be between 0 and 100");
+	const scaledPct = Math.round(utilizationPct * 1e6);
+	return BigInt(scaledPct) * WAD / 100000000n;
+}
+function utilizationBpsToWad(utilizationBps) {
+	return clampUtilizationBps(utilizationBps) * WAD / BPS_SCALE;
+}
+function ratePerSecWadToAprPct(ratePerSecWad) {
+	return Number(ratePerSecWad) * Number(SECONDS_PER_YEAR) * 100 / Number(WAD);
+}
+function deriveSupplyRatePerSecWad(borrowRatePerSecWad, utilizationWad) {
+	return borrowRatePerSecWad * utilizationWad / WAD;
+}
+async function getIrmCurrent(params) {
+	const { client, collateralTrackerAddress, blockNumber } = params;
+	const [borrowIndex, lastInteractionTimestamp, rateAtTarget, unrealizedGlobalInterest, poolData, riskEngineAddress] = await client.multicall({
+		contracts: [
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "borrowIndex"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "lastInteractionTimestamp"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "rateAtTarget"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "unrealizedGlobalInterest"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			},
+			{
+				address: collateralTrackerAddress,
+				abi: collateralTrackerV2Abi,
+				functionName: "riskEngine"
+			}
+		],
+		blockNumber,
+		allowFailure: false
+	});
+	const currentUtilizationBps = clampUtilizationBps(poolData[3]);
+	const currentUtilizationWad = utilizationBpsToWad(currentUtilizationBps);
+	const currentUtilizationPct = Number(currentUtilizationBps) / 100;
+	const marketStatePacked = packMarketState({
+		borrowIndex,
+		lastInteractionTimestamp,
+		rateAtTarget,
+		unrealizedGlobalInterest
+	});
+	const borrowRatePerSecWad = await client.readContract({
+		address: riskEngineAddress,
+		abi: riskEngineAbi,
+		functionName: "interestRate",
+		args: [currentUtilizationWad, marketStatePacked],
+		blockNumber
+	});
+	const supplyRatePerSecWad = deriveSupplyRatePerSecWad(borrowRatePerSecWad, currentUtilizationWad);
+	return {
+		collateralTrackerAddress,
+		riskEngineAddress,
+		currentUtilizationBps,
+		currentUtilizationWad,
+		currentUtilizationPct,
+		borrowRatePerSecWad,
+		supplyRatePerSecWad,
+		borrowAprPct: ratePerSecWadToAprPct(borrowRatePerSecWad),
+		supplyAprPct: ratePerSecWadToAprPct(supplyRatePerSecWad),
+		marketStatePacked
+	};
+}
+async function getIrmCurve(params) {
+	const { client, collateralTrackerAddress, points = 201, blockNumber } = params;
+	if (!Number.isInteger(points) || points < 2) throw new PanopticValidationError("points must be an integer >= 2");
+	if (points > MAX_IRM_CURVE_POINTS) throw new PanopticValidationError(`points must be <= ${MAX_IRM_CURVE_POINTS}`);
+	const current = await getIrmCurrent({
+		client,
+		collateralTrackerAddress,
+		blockNumber
+	});
+	const denominator = BigInt(points - 1);
+	const contracts = Array.from({ length: points }, (_, idx) => {
+		const i = BigInt(idx);
+		const utilizationWad = i * WAD / denominator;
+		return {
+			address: current.riskEngineAddress,
+			abi: riskEngineAbi,
+			functionName: "interestRate",
+			args: [utilizationWad, current.marketStatePacked]
+		};
+	});
+	const borrowRatesPerSecWad = await client.multicall({
+		contracts,
+		blockNumber,
+		allowFailure: false
+	});
+	const curvePoints = borrowRatesPerSecWad.map((borrowRatePerSecWad, idx) => {
+		const i = BigInt(idx);
+		const utilizationWad = i * WAD / denominator;
+		const supplyRatePerSecWad = deriveSupplyRatePerSecWad(borrowRatePerSecWad, utilizationWad);
+		return {
+			utilizationWad,
+			utilizationPct: idx * 100 / (points - 1),
+			borrowRatePerSecWad,
+			supplyRatePerSecWad,
+			borrowAprPct: ratePerSecWadToAprPct(borrowRatePerSecWad),
+			supplyAprPct: ratePerSecWadToAprPct(supplyRatePerSecWad)
+		};
+	});
+	return {
+		current,
+		points: curvePoints
+	};
+}
+
+//#endregion
+export { BORROW_INDEX_BITS, BPS_SCALE, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, Multicall3Abi, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, UNREALIZED_INTEREST_BITS, WAD, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountCollateral, getAccountSummaryBasic, getAccountSummaryRisk, getCollateralAddresses, getCollateralData, getCurrentRates, getInterestState, getIrmCurrent, getIrmCurve, getLiquidationPrices, getNetLiquidationValue, getNetLiquidationValues, isLiquidatable, packMarketState, panopticQueryAbi, parseTokenAmount, parseWad, ratePerSecWadToAprPct, readBlockAndAggregate, requireReturnData, utilizationBpsToWad, utilizationPctToWad };
+//# sourceMappingURL=irm-CBrX8bjH.js.map