@panoptic-eng/sdk 1.0.38 → 1.0.40

package/dist/{irm-ChkvYphK.js → irm-SPC2KxLA.js}

@@ -1,4 +1,4 @@
-import { MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, PanopticValidationError$1 as PanopticValidationError, collateralTrackerV2Abi, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, getBlockMeta$1 as getBlockMeta, getPool$1 as getPool, getPositions$1 as getPositions, panopticPoolV2Abi, riskEngineAbi } from "./getTrackedPositionIds-zYPIs5dt.js";
+import { MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, PanopticValidationError, collateralTrackerV2Abi, decodeLeftRightUnsigned, getBlockMeta, getPool, getPositions, panopticPoolV2Abi, riskEngineAbi } from "./getTrackedPositionIds-ms3W9dYB.js";
 import { tickToSqrtPriceX96 } from "./greeks-GysWXct-.js";
 import { decodeFunctionResult, encodeFunctionData } from "viem";
 import { call } from "viem/actions";
@@ -2285,6 +2285,325 @@ async function getInterestState(params) {
 	};
 }
 
+//#endregion
+//#region ../deployments/src/chainDeployments.data.json
+var _1 = {
+	"chainId": 1,
+	"infrastructure": {
+		"uniswapV3Factory": "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+		"poolManager": "0x000000000004444c5dc75cB358380D2e3dE08A90",
+		"stateView": "0x7ffe42c4a5deea5b0fec41c94c136cf115597227"
+	},
+	"hypovault": {
+		"core": {
+			"hypoVaultImplementation": "0xF16714665955DBd0361D997eFc50fe391D96E8D0",
+			"factory": "0xd5049B2647de57141dE7F65E5124707B99A452A3",
+			"accountant": "0x65aA902AE3135658587FFC36ED51B61c927114e1",
+			"rolesAuthority": "0xb952D345c413Ddb7850173422bAe4968e0330598",
+			"collateralTrackerDecoderAndSanitizer": "0xC87c45d2dbE5acb56013e2591427ECC84Fa251E6"
+		},
+		"vaults": {
+			"wethPlpVault": "0xd4e2c720a760049cc4151bcf61e3a9348db9cd92",
+			"usdcPlpVault": "0x236d0558f06cd60780b232d4Ec4c92d2cb7e4D18"
+		},
+		"managers": {
+			"wethPlpVaultManager": "0xB6Fc48e658C9B1a7dbdFA51A5E153ab60BB2e04d",
+			"usdcPlpVaultManager": "0x2ce65016366ef7320078e0758D58Cf1038bc7C4e"
+		},
+		"turnkeySigners": {
+			"wethPlpVaultManager": "0x8FfA6DAB99f8afc64F61BeF83F0966eD6362f24F",
+			"usdcPlpVaultManager": "0x3c1c79d0cfc316Ba959194c89696a8382d7d283b"
+		}
+	},
+	"panoptic": {
+		"pool": {
+			"version": "v4",
+			"panopticPool": "0x00000000563b70d704f4c6675a5f6ac989fbae13",
+			"collateralTracker0": "0x1e46b0289B7E0F710E2Db8Ab87800dd782D624f7",
+			"collateralTracker1": "0x12bF31955522BAC337D93e1bC0a39F68D8BDa216"
+		},
+		"additionalPools": { "ethUsdc5bpsV3": {
+			"version": "v3",
+			"panopticPool": "0x00000000009C7B687e833559e34503f64d7ed7c4",
+			"collateralTracker0": "0x3CCdA7d5E841d6543D90BcEc20b36a724C184DE9",
+			"collateralTracker1": "0x69E9f9e44E5F52237493b980dd7306198C64A4E4"
+		} },
+		"v2": {
+			"semiFungiblePositionManagerV4": "0x000000000000047534b9E1D528ED997169865a64",
+			"semiFungiblePositionManagerV3": "0x000000000000031d296bBA22f188472157eEb01f",
+			"builderFactory": "0x00000000000008D41F2cd5bF144F61cEB3661F98",
+			"riskEngine": "0x0000000000000e673aECBDB5f5fE5DFAf4a8e9Ac",
+			"panopticPoolImplementation": "0x00000000000010bb6695dAAC60D0515c0A01a948",
+			"collateralTrackerImplementation": "0x0000000000002038055dB8f2B2Fd356598935C51",
+			"panopticFactoryV4": "0x0000000000000c51d0f8cf4bd9adE7191372a625",
+			"panopticFactoryV3": "0x0000000000000aDC9A108591e718F2aee963a2a7",
+			"panopticHelper": "0x0000000000000000000000000000000000000000",
+			"panopticMath": "0x000000000000301F5BC0171C75967b8e78a92b10",
+			"panopticQuery": "0x0000000000000e1aE9c66C1c3B0A547D23389C93",
+			"interactionHelper": "0x00000000000040ae7CD505F4E0e3F34195D8c08C"
+		}
+	},
+	"riskEngines": [
+		"0x000000000000075e29cdaa9cb640a69e148ca7da",
+		"0x0000000000000fe1e261f66ce2f44def4f5ae0cb",
+		"0x0000000000000e673aECBDB5f5fE5DFAf4a8e9Ac"
+	],
+	"markets": { "ethUsdc30bps": {
+		"currency0": "0x0000000000000000000000000000000000000000",
+		"currency1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"fee": 3e3,
+		"tickSpacing": 60,
+		"poolId": "0x3C08AE4977F78D"
+	} },
+	"subgraphs": {
+		"hypovault": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/hypovault-subgraph-mainnet/prod/gn",
+		"panoptic": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/panoptic-subgraph-mainnet/v2_prod/gn"
+	},
+	"sfpmSwap": {
+		"version": "v3",
+		"sfpm": "0x00000000000005E4693aDc8Ec0f12D686f728198",
+		"poolAddress": "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
+		"poolId": "2824133844976349",
+		"fee": 500,
+		"weth": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+	}
+};
+var _8453 = {
+	"chainId": 8453,
+	"infrastructure": {
+		"uniswapV3Factory": "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+		"poolManager": "0x498581fF718922c3f8e6A244956aF099B2652b2b",
+		"stateView": "0xA3c0c9b65baD0b08107Aa264b0f3dB444b867A71"
+	},
+	"hypovault": {
+		"core": {
+			"hypoVaultImplementation": "0xec311aE06486ad44Ba782133b502A34aCE0f479E",
+			"factory": "0x9bE53b169a41030f1710A9B82e9eA6413f14D12E",
+			"accountant": "0x345cA3407942f9d175c9eA8B90e83A36F570f852",
+			"rolesAuthority": "0x278D37CaBFFB4B72D2866E30fEFE08aef773E0B6",
+			"collateralTrackerDecoderAndSanitizer": "0x4A290b3EC46cF320421Bb2aaee96d445de31CF0b"
+		},
+		"vaults": {
+			"wethPlpVault": "0x41b7D0515d709A4Fd2CF27f9d141D0c2F8713D04",
+			"usdcPlpVault": "0xb452af299c565D04B05E601efF2840e000C922f1"
+		},
+		"managers": {
+			"wethPlpVaultManager": "0x2a4923456c79E9ebD10F5Bf5305a5C742bBc1D7C",
+			"usdcPlpVaultManager": "0xdd6E2406a044582463CFE9F0C774870eAf4A310B"
+		},
+		"turnkeySigners": {
+			"wethPlpVaultManager": "0x8FfA6DAB99f8afc64F61BeF83F0966eD6362f24F",
+			"usdcPlpVaultManager": "0x3c1c79d0cfc316Ba959194c89696a8382d7d283b"
+		}
+	},
+	"panoptic": {
+		"pool": {
+			"version": "v4",
+			"panopticPool": "0xB50e8bb68f5855DA742f4579274902a20454174a",
+			"collateralTracker0": "0x0d82b189c96EbB1f44A7207e6A9cfB1e490f2869",
+			"collateralTracker1": "0x9ba1082Ab3cb9edEA988697A14BBe543A3dABEd2"
+		},
+		"v2": {
+			"semiFungiblePositionManagerV4": "0x8dcAa08cF298F8b4830FAf56d47930981AdE33af",
+			"semiFungiblePositionManagerV3": "0xFB1c06B491305d618bb8a7a368C6e50c001C153A",
+			"builderFactory": "0x6d26E916a18d522f7DdA2a26d9E1645564ccDcA5",
+			"riskEngine": "0x8bbce8b1eb64118cfe6c1eab0afe13b80ea41481",
+			"panopticPoolImplementation": "0x5BA68a018fF149c38ec52D181Dd24aBabE9a07DB",
+			"collateralTrackerImplementation": "0x34B3a4e4F14f292575ECe3EF67886C4598af459f",
+			"panopticFactoryV4": "0x9ac0317fcd124aff0b5429beb8de17020bc45f9a",
+			"panopticFactoryV3": "0x687f616d68c483a7223e6922f59aef7452e26c1d",
+			"panopticHelper": "0x0000000000000000000000000000000000000000",
+			"panopticMath": "0x6d21699192f5aF112C87e53b32ff846782afF407",
+			"panopticQuery": "0xd2586E1bbdd1169F597F3A370117EdF7372A7350",
+			"interactionHelper": "0x643d8DD5372FD6c71f8fAbCce4Eb8857704F3E15"
+		}
+	},
+	"riskEngines": ["0x8bbce8b1eb64118cfe6c1eab0afe13b80ea41481"],
+	"markets": { "ethUsdc5bps": {
+		"currency0": "0x0000000000000000000000000000000000000000",
+		"currency1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+		"fee": 500,
+		"tickSpacing": 10,
+		"poolId": "0x96d4b53a38337a5733179751781178a2613306063c511b78cd02684739288c0a"
+	} },
+	"subgraphs": {
+		"hypovault": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/hypovault-subgraph-base/prod/gn",
+		"panoptic": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/panoptic-subgraph-base/v2_prod/gn"
+	}
+};
+var _11155111 = {
+	"chainId": 11155111,
+	"infrastructure": {
+		"uniswapV3Factory": "0x0227628f3F023bb0B980b67D528571c95c6DaC1c",
+		"poolManager": "0xE03A1074c86CFeDd5C142C4F04F1a1536e203543",
+		"stateView": "0xE1Dd9c3fA50EDB962E442f60DfBc432e24537E4C"
+	},
+	"hypovault": {
+		"core": {
+			"hypoVaultImplementation": "0xC5b415Db4087228Af817893769DC3a205160160B",
+			"factory": "0x363a9d605ca45cBfF3b597350DeADb53cdC292c7",
+			"accountant": "0x25BBef1DF262c24aa1AACD1F7eCeEcc1a7AD08ab",
+			"rolesAuthority": "0x673BfafB4e2712215B422347c1571421B83E8A3d",
+			"collateralTrackerDecoderAndSanitizer": "0xb899BE50BAF25BBB3A3ca3403256B3c703E5AB5d"
+		},
+		"vaults": {
+			"wethPlpVault": "0xD58C4F9AEe5bBfcf28dC9a8d3D57b323fA6521b1",
+			"usdcPlpVault": "0xdd7a8d6c6975488e801129bC84302d74e2361208"
+		},
+		"managers": {
+			"wethPlpVaultManager": "0x95eC124FAAB70D7aE147c3BE0336E01a828AE2d5",
+			"usdcPlpVaultManager": "0xFB5aa3e0b46F3859D90B14b52ffd287013b5Ec53"
+		},
+		"turnkeySigners": {
+			"wethPlpVaultManager": "0x8FfA6DAB99f8afc64F61BeF83F0966eD6362f24F",
+			"usdcPlpVaultManager": "0x3c1c79d0cfc316Ba959194c89696a8382d7d283b"
+		}
+	},
+	"panoptic": {
+		"pool": {
+			"version": "v4",
+			"panopticPool": "0x872b98C46b2062F663BEb2CC9D4cE046Da2a2918",
+			"collateralTracker0": "0x09a60b78d06a03e5148faedd3bfee6f58b22012f",
+			"collateralTracker1": "0x7365664c8101ff7e9422ae2b203822253c31e69c"
+		},
+		"v2": {
+			"semiFungiblePositionManagerV3": "0x9DaD2C40107Db4B29a5450401BB7A28e6eA00e43",
+			"semiFungiblePositionManagerV4": "0xD2615995A71644E122cC2FD7FeC2392b971220DE",
+			"builderFactory": "0x55f3D2d9D065AA5Fcc11D94c55a6085849e8b6C3",
+			"riskEngine": "0x1376aF5ca426B6B9fad6a712c21f6Cf58a94b93c",
+			"panopticPoolImplementation": "0x969235B5830f13b58BB699305d9c70A8Cd3BD97C",
+			"collateralTrackerImplementation": "0xafcd5F651Ae0403Ff668bb2dAc38BEa907a35Dba",
+			"panopticFactoryV3": "0xd9FFCa53C0A6155001Ce8cbcAEfe89DB204690F1",
+			"panopticFactoryV4": "0x8FCBb59b05779818D9BAD2686cc44B705603ce03",
+			"panopticHelper": "0xfFEbB3A4ab793cB244209d4dA0Cb3e6B07133bd0",
+			"panopticMath": "0x6d21699192f5aF112C87e53b32ff846782afF407",
+			"panopticQuery": "0x74057945467Fb4eAE9193B46A60ae66a53f06A5b",
+			"interactionHelper": "0x643d8DD5372FD6c71f8fAbCce4Eb8857704F3E15"
+		}
+	},
+	"riskEngines": ["0x1376aF5ca426B6B9fad6a712c21f6Cf58a94b93c"],
+	"markets": { "ethUsdc5bps": {
+		"currency0": "0x0000000000000000000000000000000000000000",
+		"currency1": "0xFFFeD8254566B7F800f6D8CDb843ec75AE49B07A",
+		"fee": 500,
+		"tickSpacing": 10,
+		"poolId": "0xba6673bcb27568a73a93dd23b20c8174fa16193cd90905be859144e8f13097a5"
+	} },
+	"subgraphs": {
+		"hypovault": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/hypovault-subgraph-sepolia/prod/gn",
+		"panoptic": "https://api.goldsky.com/api/public/project_cl9gc21q105380hxuh8ks53k3/subgraphs/panoptic-subgraph-sepolia/v2_prod/gn"
+	}
+};
+var chainDeployments_data_default = {
+	"1": _1,
+	"8453": _8453,
+	"11155111": _11155111
+};
+
+//#endregion
+//#region ../deployments/src/chainDeployments.js
+const MAINNET_CHAIN_ID = 1;
+const SEPOLIA_CHAIN_ID = 11155111;
+const BASE_CHAIN_ID = 8453;
+const CHAIN_DEPLOYMENTS = chainDeployments_data_default;
+function getChainDeployment(chainId) {
+	return CHAIN_DEPLOYMENTS[chainId];
+}
+function requireChainDeployment(chainId) {
+	const deployment = getChainDeployment(chainId);
+	if (deployment === void 0) throw new Error(`Unsupported chain deployment for chainId ${chainId}`);
+	return deployment;
+}
+function isSupportedChain(chainId) {
+	return getChainDeployment(chainId) !== void 0;
+}
+function getEthUsdcMarket(deployment) {
+	const market = deployment.markets.ethUsdc5bps ?? deployment.markets.ethUsdc30bps;
+	if (market === void 0) throw new Error(`Missing ETH/USDC market for chainId ${deployment.chainId}`);
+	return market;
+}
+const MAINNET_DEPLOYMENT = CHAIN_DEPLOYMENTS[MAINNET_CHAIN_ID];
+const MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.additionalPools?.ethUsdc5bpsV3;
+const MAINNET_PANOPTIC_V2_ADDRESSES = MAINNET_DEPLOYMENT.panoptic.v2;
+const SEPOLIA_DEPLOYMENT = CHAIN_DEPLOYMENTS[SEPOLIA_CHAIN_ID];
+const SEPOLIA_HYPOVAULT_CORE_ADDRESSES = SEPOLIA_DEPLOYMENT.hypovault.core;
+const SEPOLIA_HYPOVAULT_ADDRESSES = SEPOLIA_DEPLOYMENT.hypovault.vaults;
+const SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES = SEPOLIA_DEPLOYMENT.hypovault.managers;
+const SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS = SEPOLIA_DEPLOYMENT.hypovault.turnkeySigners;
+const SEPOLIA_PANOPTIC_POOL_ADDRESSES = SEPOLIA_DEPLOYMENT.panoptic.pool;
+const SEPOLIA_PANOPTIC_V2_ADDRESSES = SEPOLIA_DEPLOYMENT.panoptic.v2;
+const BASE_DEPLOYMENT = CHAIN_DEPLOYMENTS[BASE_CHAIN_ID];
+const BASE_HYPOVAULT_CORE_ADDRESSES = BASE_DEPLOYMENT.hypovault.core;
+const BASE_HYPOVAULT_ADDRESSES = BASE_DEPLOYMENT.hypovault.vaults;
+const BASE_HYPOVAULT_MANAGER_ADDRESSES = BASE_DEPLOYMENT.hypovault.managers;
+const BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS = BASE_DEPLOYMENT.hypovault.turnkeySigners;
+const BASE_PANOPTIC_POOL_ADDRESSES = BASE_DEPLOYMENT.panoptic.pool;
+const BASE_PANOPTIC_V2_ADDRESSES = BASE_DEPLOYMENT.panoptic.v2;
+const BASE_ETH_USDC_5BPS_MARKET = getEthUsdcMarket(BASE_DEPLOYMENT);
+const SEPOLIA_ETH_USDC_5BPS_MARKET = getEthUsdcMarket(SEPOLIA_DEPLOYMENT);
+const MAINNET_RISK_ENGINES = MAINNET_DEPLOYMENT.riskEngines;
+const BASE_RISK_ENGINES = BASE_DEPLOYMENT.riskEngines;
+const SEPOLIA_RISK_ENGINES = SEPOLIA_DEPLOYMENT.riskEngines;
+
+//#endregion
+//#region ../deployments/src/vaultDisplayNames.js
+const mainnetDeployment = requireChainDeployment(MAINNET_CHAIN_ID);
+const mainnetVaults = mainnetDeployment.hypovault.vaults;
+const legacyMainnetVaults = {
+	wethPlpVault: "0x779a2aa634A004b3a3f3b322083744869BBC6D66",
+	usdcPlpVault: "0x963Fe9c93bc353602656ee4051A75114bA74d6c5"
+};
+const sepoliaDeployment = requireChainDeployment(SEPOLIA_CHAIN_ID);
+const sepoliaVaults = sepoliaDeployment.hypovault.vaults;
+const baseDeployment = requireChainDeployment(BASE_CHAIN_ID);
+const baseVaults = baseDeployment.hypovault.vaults;
+const VAULT_DISPLAY_NAMES_PER_CHAIN = {
+	[MAINNET_CHAIN_ID]: {
+		[mainnetVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
+		[mainnetVaults.usdcPlpVault.toLowerCase()]: "Unicorn Vault",
+		[legacyMainnetVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
+		[legacyMainnetVaults.usdcPlpVault.toLowerCase()]: "Unicorn Vault"
+	},
+	[BASE_CHAIN_ID]: {
+		[baseVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
+		[baseVaults.usdcPlpVault.toLowerCase()]: "Unicorn Vault"
+	},
+	[SEPOLIA_CHAIN_ID]: {
+		[sepoliaVaults.wethPlpVault.toLowerCase()]: "PLP Vault",
+		[sepoliaVaults.usdcPlpVault.toLowerCase()]: "Unicorn Vault"
+	}
+};
+const VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN = {
+	[MAINNET_CHAIN_ID]: {
+		[mainnetVaults.wethPlpVault.toLowerCase()]: () => "PLP Vault",
+		[mainnetVaults.usdcPlpVault.toLowerCase()]: () => "Unicorn Vault",
+		[legacyMainnetVaults.wethPlpVault.toLowerCase()]: () => "PLP Vault",
+		[legacyMainnetVaults.usdcPlpVault.toLowerCase()]: () => "Unicorn Vault"
+	},
+	[BASE_CHAIN_ID]: {
+		[baseVaults.wethPlpVault.toLowerCase()]: () => "PLP Vault",
+		[baseVaults.usdcPlpVault.toLowerCase()]: () => "Unicorn Vault"
+	},
+	[SEPOLIA_CHAIN_ID]: {
+		[sepoliaVaults.wethPlpVault.toLowerCase()]: () => "PLP Vault",
+		[sepoliaVaults.usdcPlpVault.toLowerCase()]: () => "Unicorn Vault"
+	}
+};
+function resolveVaultDisplayName({ chainId, vaultAddress, underlyingSymbol, fallbackName }) {
+	const vaultAddressLower = vaultAddress.toLowerCase();
+	const resolver = VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN[chainId]?.[vaultAddressLower];
+	if (resolver !== void 0) return resolver({
+		chainId,
+		vaultAddress: vaultAddressLower,
+		underlyingSymbol,
+		fallbackName
+	});
+	const staticName = VAULT_DISPLAY_NAMES_PER_CHAIN[chainId]?.[vaultAddressLower];
+	if (staticName !== void 0) return staticName;
+	if (fallbackName !== void 0 && fallbackName !== null) return fallbackName;
+	return "Vault";
+}
+
 //#endregion
 //#region src/panoptic/v2/formatters/amount.ts
 /**
@@ -2686,5 +3005,4 @@ async function getIrmCurve(params) {
 }
 
 //#endregion
-export { BORROW_INDEX_BITS, BPS_SCALE, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, Multicall3Abi, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, StateViewAbi, UNREALIZED_INTEREST_BITS, WAD as WAD$2, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad as formatRateWad$1, formatTokenAmount as formatTokenAmount$1, formatTokenAmountSigned as formatTokenAmountSigned$1, formatTokenDelta as formatTokenDelta$1, formatTokenFlow as formatTokenFlow$1, formatWad as formatWad$1, formatWadPercent as formatWadPercent$1, formatWadSigned as formatWadSigned$1, getAccountCollateral as getAccountCollateral$1, getAccountSummaryBasic as getAccountSummaryBasic$1, getAccountSummaryRisk as getAccountSummaryRisk$1, getCollateralAddresses as getCollateralAddresses$1, getCollateralData as getCollateralData$1, getCurrentRates as getCurrentRates$1, getInterestState as getInterestState$1, getIrmCurrent, getIrmCurve, getLiquidationPrices as getLiquidationPrices$1, getNetLiquidationValue as getNetLiquidationValue$1, getNetLiquidationValues as getNetLiquidationValues$1, isLiquidatable as isLiquidatable$1, packMarketState, panopticQueryAbi as panopticQueryAbi$1, parseTokenAmount as parseTokenAmount$1, parseWad as parseWad$1, ratePerSecWadToAprPct, readBlockAndAggregate, requireReturnData, utilizationBpsToWad, utilizationPctToWad };
-//# sourceMappingURL=irm-ChkvYphK.js.map
+export { BASE_CHAIN_ID, BASE_DEPLOYMENT, BASE_ETH_USDC_5BPS_MARKET, BASE_HYPOVAULT_ADDRESSES, BASE_HYPOVAULT_CORE_ADDRESSES, BASE_HYPOVAULT_MANAGER_ADDRESSES, BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, BASE_PANOPTIC_POOL_ADDRESSES, BASE_PANOPTIC_V2_ADDRESSES, BORROW_INDEX_BITS, BPS_SCALE, CHAIN_DEPLOYMENTS, MAINNET_CHAIN_ID, MAINNET_DEPLOYMENT, MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES, MAINNET_PANOPTIC_V2_ADDRESSES, MAINNET_RISK_ENGINES, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, Multicall3Abi, RATE_AT_TARGET_BITS, SECONDS_PER_YEAR, SEPOLIA_CHAIN_ID, SEPOLIA_DEPLOYMENT, SEPOLIA_ETH_USDC_5BPS_MARKET, SEPOLIA_HYPOVAULT_ADDRESSES, SEPOLIA_HYPOVAULT_CORE_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, SEPOLIA_PANOPTIC_POOL_ADDRESSES, SEPOLIA_PANOPTIC_V2_ADDRESSES, StateViewAbi, UNREALIZED_INTEREST_BITS, VAULT_DISPLAY_NAMES_PER_CHAIN, VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN, WAD as WAD$1, annualizePerSecondRateWad, deriveSupplyRatePerSecWad, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountCollateral, getAccountSummaryBasic, getAccountSummaryRisk, getChainDeployment, getCollateralAddresses, getCollateralData, getCurrentRates, getEthUsdcMarket, getInterestState, getIrmCurrent, getIrmCurve, getLiquidationPrices, getNetLiquidationValue, getNetLiquidationValues, isLiquidatable, isSupportedChain, packMarketState, panopticQueryAbi as panopticQueryAbi$1, parseTokenAmount, parseWad, ratePerSecWadToAprPct, readBlockAndAggregate, requireChainDeployment, requireReturnData, resolveVaultDisplayName, utilizationBpsToWad, utilizationPctToWad };

package/dist/panoptic/v2/greeks/index.d.ts

@@ -1,4 +1,277 @@
-import "../../../index-Bo9tHtD7.js";
-import "../../../irm-D5plRhpB.js";
-import { PositionGreeksInput, PositionGreeksResult, calculatePortfolioDelta$1 as calculatePortfolioDelta, calculatePortfolioGamma$1 as calculatePortfolioGamma, calculatePortfolioGreeks$1 as calculatePortfolioGreeks, calculatePortfolioValue$1 as calculatePortfolioValue, calculatePositionDelta$1 as calculatePositionDelta, calculatePositionDeltaDebtOnly$1 as calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap$1 as calculatePositionDeltaWithSwap, calculatePositionGamma$1 as calculatePositionGamma, calculatePositionGreeks$1 as calculatePositionGreeks, calculatePositionValue$1 as calculatePositionValue, getLegDelta$1 as getLegDelta, getLegDeltaInVaultFrame$1 as getLegDeltaInVaultFrame, getLegGamma$1 as getLegGamma, getLegNetValueWidth0$1 as getLegNetValueWidth0, getLegValue$1 as getLegValue, getLoanEffectiveDelta$1 as getLoanEffectiveDelta, isCall$1 as isCall, isDefinedRisk$1 as isDefinedRisk, toVaultFrameAtTick$1 as toVaultFrameAtTick } from "../../../index-DktZq9Kb.js";
-export { PositionGreeksInput, PositionGreeksResult, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, isCall, isDefinedRisk, toVaultFrameAtTick };
+import "viem";
+
+//#region src/panoptic/v2/types/position.d.ts
+/**
+* A single leg of a TokenId.
+*/
+
+/**
+ * A single leg of a TokenId.
+ */
+interface TokenIdLeg {
+  /** Leg index (0-3) */
+  index: bigint;
+  /** Asset index (0 or 1) */
+  asset: bigint;
+  /** Option ratio (1-127) */
+  optionRatio: bigint;
+  /** Whether this is a long position (true) or short (false) */
+  isLong: boolean;
+  /** Token type (0 or 1) - which token is being moved */
+  tokenType: bigint;
+  /** Risk partner leg index (for spreads) */
+  riskPartner: bigint;
+  /** Strike tick (center of the range) */
+  strike: bigint;
+  /** Width in tick spacing units */
+  width: bigint;
+  /** Lower tick of the range */
+  tickLower: bigint;
+  /** Upper tick of the range */
+  tickUpper: bigint;
+} //#endregion
+//#region src/panoptic/v2/greeks/index.d.ts
+
+/**
+ * Position data.
+ */
+
+/**
+ * Calculate the NET (user-experienced) payoff value for a width=0 (loan/credit) leg.
+ *
+ * Unlike `getLegValueWidth0` (debt-only), this includes the collateral/holding side and
+ * therefore depends on how the position was opened:
+ *
+ * - **Cover at mint** (`swapAtMint = false`): the collateral is sourced in the SAME token as
+ *   the debt/credit, so the holding side exactly offsets it → net PnL is FLAT (0 everywhere,
+ *   mint-relative), regardless of which token the leg is denominated in.
+ * - **Zap** (`swapAtMint = true`): the collateral is sourced in the OTHER token, leaving a
+ *   ±1-delta line in the asset (ETH), anchored to 0 at the mint price:
+ *     - USDC loan  → zap to ETH:   +1 (long ETH)
+ *     - ETH  loan  → zap to USDC:  −1 (short ETH)
+ *     - USDC credit ← zap from ETH: −1 (short ETH)
+ *     - ETH  credit ← zap from USDC: +1 (long ETH)
+ *
+ * @returns Net leg value in numeraire token smallest units (mint-relative PnL).
+ */
+declare function getLegNetValueWidth0(leg: TokenIdLeg, m: bigint, qCurrentTick: bigint, qMintTick: bigint, isAssetToken0: boolean, swapAtMint: boolean, itmOffsetNotional?: bigint): bigint;
+/**
+ * Check if leg is a call option (vs put).
+ *
+ * A call is when the leg moves the asset token:
+ * - If asset is token0: call when tokenType=0
+ * - If asset is token1: call when tokenType=1
+ */
+declare function isCall(tokenType: bigint, isAssetToken0: boolean): boolean;
+/**
+ * Check if position has defined risk (is a spread).
+ *
+ * A position is defined risk if it has 2+ legs of the same tokenType
+ * with both long and short exposure.
+ */
+declare function isDefinedRisk(legs: Pick<TokenIdLeg, 'tokenType' | 'isLong'>[]): boolean;
+/**
+ * Calculate the value of a single leg.
+ *
+ * Value represents the current P&L of the position in numeraire token units.
+ * Combines base value (from Panoptic's piecewise formula), debt, and ITM adjustment.
+ *
+ * Uses sqrtPriceX96 for all calculations to maintain precision and on-chain fidelity.
+ *
+ * @param leg - The leg to calculate
+ * @param currentTick - Current pool tick
+ * @param mintTick - Tick at position mint
+ * @param positionSize - Position size in asset token smallest units
+ * @param poolTickSpacing - Pool tick spacing
+ * @param definedRisk - Whether position is defined risk
+ * @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+ * @returns Leg value in numeraire token smallest units
+ */
+declare function getLegValue(leg: TokenIdLeg, currentTick: bigint, mintTick: bigint, positionSize: bigint, poolTickSpacing: bigint, definedRisk: boolean, assetIndex?: bigint, swapAtMint?: boolean): bigint;
+/**
+ * Calculate the delta of a single leg.
+ *
+ * Delta is the rate of change of position value with respect to price.
+ * For puts: delta = vDelta
+ * For calls: delta = debtDelta + vDelta + itmDelta (if not defined risk)
+ *
+ * Uses sqrtPriceX96 for all price calculations to maintain precision.
+ *
+ * @param leg - The leg to calculate
+ * @param currentTick - Current pool tick
+ * @param positionSize - Position size in asset token smallest units
+ * @param poolTickSpacing - Pool tick spacing
+ * @param mintTick - Tick at mint (optional, for ITM adjustment)
+ * @param definedRisk - Whether position is defined risk
+ * @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+ * @returns Leg delta in asset token smallest units
+ */
+declare function getLegDelta(leg: TokenIdLeg, currentTick: bigint, positionSize: bigint, poolTickSpacing: bigint, mintTick: bigint | undefined, definedRisk: boolean, assetIndex?: bigint): bigint;
+/** Convert a delta between token frames at the current pool tick. */
+declare function toVaultFrameAtTick(delta: bigint, fromAsset: bigint, vaultAssetIndex: 0n | 1n, currentTick: bigint, flipSignOnAssetInversion?: boolean): bigint;
+/**
+ * Calculate one leg's wallet-aware delta in the vault asset frame.
+ *
+ * Width-zero loans and credits must be evaluated directly in the vault frame.
+ * Option legs remain in their natural leg frame until converted at the mark tick.
+ */
+declare function getLegDeltaInVaultFrame(leg: TokenIdLeg, currentTick: bigint, positionSize: bigint, poolTickSpacing: bigint, mintTick: bigint | undefined, definedRisk: boolean, vaultAssetIndex: 0n | 1n): bigint;
+/**
+ * Calculate the gamma (dollar gamma) of a single leg.
+ *
+ * Formula: gamma = (m * sqrt(K * P * r)) / (2 * (r - 1))
+ * where:
+ * - m = positionSize * optionRatio (with sign based on long/short)
+ * - K = strike price (numeraire/asset)
+ * - P = current price (numeraire/asset)
+ * - r = 1.0001^(width*tickSpacing/2) ≈ 1 (dimensionless ratio)
+ *
+ * Uses sqrtPriceX96 arithmetic:
+ * - sqrt(K*P*r) = tickToSqrtPriceX96(strikeₜ + currentₜ + widthₜ/2)
+ * - Keeps X96/X192 precision until final division
+ *
+ * @param leg - The leg to calculate
+ * @param currentTick - Current pool tick
+ * @param positionSize - Position size in asset token smallest units
+ * @param poolTickSpacing - Pool tick spacing
+ * @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+ * @returns Leg gamma in numeraire token smallest units
+ */
+declare function getLegGamma(leg: TokenIdLeg, currentTick: bigint, positionSize: bigint, poolTickSpacing: bigint, assetIndex?: bigint): bigint;
+/**
+ * Parameters for position-level greek calculations.
+ */
+interface PositionGreeksInput {
+  /** Position legs */
+  legs: TokenIdLeg[];
+  /** Current pool tick */
+  currentTick: bigint;
+  /** Tick at position mint */
+  mintTick: bigint;
+  /** Position size in asset token smallest units */
+  positionSize: bigint;
+  /** Pool tick spacing */
+  poolTickSpacing: bigint;
+  /** Optional override for leg.asset on all legs (0n = token0 is asset, 1n = token1) */
+  assetIndex?: bigint;
+  /**
+   * How width=0 (loan/credit) legs were opened. When provided, `calculatePositionValue`
+   * returns the NET user-experienced payoff for those legs (Zap = ±1 line, Cover = flat)
+   * instead of the debt-only value. Leave undefined for delta/greeks aggregation, which
+   * accounts for the held collateral separately.
+   */
+  swapAtMint?: boolean;
+}
+/**
+ * Calculate total value across all legs.
+ */
+declare function calculatePositionValue(input: PositionGreeksInput): bigint;
+/**
+ * Calculate total delta across all legs.
+ */
+declare function calculatePositionDelta(input: PositionGreeksInput): bigint;
+/**
+ * Calculate debt-only position delta in a single target asset frame.
+ *
+ * Option legs are first valued in their natural `leg.asset` frame, then
+ * converted into `assetIndex` using the current pool price. Width-zero legs
+ * are evaluated directly in the target frame.
+ *
+ * Width=0 loan/credit legs include only their debt obligation. The held-token
+ * side must be added separately from account collateral balances, preventing a
+ * zap from being counted once in the position and again in collateral.
+ */
+declare function calculatePositionDeltaDebtOnly(input: Omit<PositionGreeksInput, 'assetIndex' | 'swapAtMint'> & {
+  assetIndex: 0n | 1n;
+}): bigint;
+/**
+ * Calculate total gamma across all legs.
+ */
+declare function calculatePositionGamma(input: PositionGreeksInput): bigint;
+/**
+ * Position greeks result.
+ */
+interface PositionGreeksResult {
+  /** Position value in numeraire token smallest units */
+  value: bigint;
+  /** Position delta in asset token smallest units */
+  delta: bigint;
+  /** Position gamma in numeraire token smallest units */
+  gamma: bigint;
+}
+/**
+ * Calculate all greeks for a position.
+ */
+declare function calculatePositionGreeks(input: PositionGreeksInput): PositionGreeksResult;
+/**
+ * Aggregate value across multiple independent positions.
+ *
+ * Each entry is valued with its OWN `positionSize`, `mintTick`, and legs, then
+ * summed. Do NOT collapse multiple positions into one synthetic `PositionGreeksInput`
+ * with a shared `positionSize` — `m = positionSize * optionRatio` is per-position, so a
+ * shared size double-counts (and integer `optionRatio` cannot encode fractional shares).
+ *
+ * @param positions - One `PositionGreeksInput` per open position
+ * @returns Total value in numeraire token smallest units
+ */
+declare function calculatePortfolioValue(positions: PositionGreeksInput[]): bigint;
+/**
+ * Aggregate delta across multiple independent positions.
+ *
+ * See {@link calculatePortfolioValue} for why each position must keep its own
+ * `positionSize` rather than being merged into one synthetic position.
+ *
+ * @param positions - One `PositionGreeksInput` per open position
+ * @returns Total delta in asset token smallest units
+ */
+declare function calculatePortfolioDelta(positions: PositionGreeksInput[]): bigint;
+/**
+ * Aggregate gamma across multiple independent positions.
+ *
+ * See {@link calculatePortfolioValue} for why each position must keep its own
+ * `positionSize` rather than being merged into one synthetic position.
+ *
+ * @param positions - One `PositionGreeksInput` per open position
+ * @returns Total gamma in numeraire token smallest units
+ */
+declare function calculatePortfolioGamma(positions: PositionGreeksInput[]): bigint;
+/**
+ * Calculate all greeks aggregated across multiple independent positions.
+ */
+declare function calculatePortfolioGreeks(positions: PositionGreeksInput[]): PositionGreeksResult;
+/**
+ * Calculate the effective delta of a loan leg accounting for swapAtMint.
+ *
+ * A loan borrows one token and (optionally) swaps it for the other at mint.
+ * The net delta depends on whether the swap occurred:
+ *
+ * | Scenario              | Result                                          |
+ * |-----------------------|-------------------------------------------------|
+ * | No swap               | 0n (hold what you owe, net zero)                |
+ * | Swap + borrows asset  | -m (hold numeraire, owe asset → short exposure) |
+ * | Swap + borrows numer. | +m (hold asset, owe numeraire → long exposure)  |
+ *
+ * Only meaningful for legs with `width === 0n`. For options, use `getLegDelta`.
+ *
+ * @param leg - The loan leg
+ * @param positionSize - Position size in asset token smallest units
+ * @param swapAtMint - Whether the borrowed tokens were swapped at mint
+ * @param assetIndex - Optional override for leg.asset (0n = token0 is asset)
+ * @returns Effective delta in asset token smallest units
+ */
+declare function getLoanEffectiveDelta(leg: TokenIdLeg, positionSize: bigint, swapAtMint: boolean, assetIndex?: bigint): bigint;
+/**
+ * Calculate total delta for a position, using swap-aware delta for loan legs.
+ *
+ * For legs with `width === 0n` (loans/credits), uses `getLoanEffectiveDelta`
+ * which accounts for the swapAtMint flag. For option legs (`width > 0n`),
+ * uses the standard `getLegDelta`.
+ *
+ * @param input - Position greeks input plus swapAtMint flag
+ * @returns Total delta in asset token smallest units
+ */
+declare function calculatePositionDeltaWithSwap(input: PositionGreeksInput & {
+  swapAtMint: boolean;
+}): bigint; //#endregion
+export { PositionGreeksInput, PositionGreeksResult, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, isCall, isDefinedRisk, toVaultFrameAtTick };
+//# sourceMappingURL=index.d.ts.map

package/dist/panoptic/v2/greeks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Address","BlockMeta","TokenIdLeg","Position","LegGreeksParams","PositionGreeks","ClosedPosition","RealizedPnL","StoredPositionData","StoredPoolMeta","TokenIdLeg","getLegNetValueWidth0","isCall","isDefinedRisk","Pick","getLegValue","getLegDelta","toVaultFrameAtTick","getLegDeltaInVaultFrame","getLegGamma","PositionGreeksInput","calculatePositionValue","calculatePositionDelta","calculatePositionDeltaDebtOnly","Omit","calculatePositionGamma","PositionGreeksResult","calculatePositionGreeks","calculatePortfolioValue","calculatePortfolioDelta","calculatePortfolioGamma","calculatePortfolioGreeks","getLoanEffectiveDelta","calculatePositionDeltaWithSwap"],"sources":["../../../../src/panoptic/v2/types/position.d.ts","../../../../src/panoptic/v2/greeks/index.d.ts"],"sourcesContent":null,"mappings":";;;;;;;AASA;;;UAAiBU,UAAAA;;;;;;;;;;;;;;;;;;;EC0BOC;;;;;;;;;;;;;;;;;;;;AAAxB;;;;;;;iBAAwBA,oBAAAA,MAA0BD;AAQlD;;;;;;;AAOwBG,iBAPAD,MAAAA,CAOa,SAAA,EAAA,MAAA,EAAA,aAAA,EAAA,OAAA,CAAA,EAAA,OAAA;;;;AAAW;;;iBAAxBC,aAAAA,OAAoBC,KAAKJ;;;;;;;;;;;;;;;AAkBjD;;;iBAAwBK,WAAAA,MAAiBL;;;;;;;;;;;;;;;;AAmBzC;;AAEA;iBAFwBM,WAAAA,MAAiBN;;iBAEjBO,kBAAAA;;;;AAOxB;;;iBAAwBC,uBAAAA,MAA6BR;;;;;;;;;;;;;;;;;;;AAsBrD;;;iBAAwBS,WAAAA,MAAiBT;AAIzC;;;UAAiBU,mBAAAA;EAwBOC;QAtBdX;;;EA0BcY;;;;;;;;;;;;AAYxB;;EAAsD,UAAaF,CAAAA,EAAAA,OAAAA;;AAAD;;;iBAhB1CC,sBAAAA,QAA8BD;AAsBtD;;;iBAlBwBE,sBAAAA,QAA8BF;AAsBtD;;;;AAWA;;;;AAAiG;;;iBArBzEG,8BAAAA,QAAsCC,KAAKJ;;;;;;iBAM3CK,sBAAAA,QAA8BL;;;AA2BtD;UAvBiBM,oBAAAA;;;;;;;;;AAiCjB;;iBAtBwBC,uBAAAA,QAA+BP,sBAAsBM;;;;;;;;AAgC7E;;;;AAIwBK,iBAxBAH,uBAAAA,CAwBwB,SAAA,EAxBWR,mBAwBX,EAAA,CAAA,EAAA,MAAA;;;;AAAwD;;;;;;iBAdhFS,uBAAAA,YAAmCT;;;;;;;;;;iBAUnCU,uBAAAA,YAAmCV;;;;iBAInCW,wBAAAA,YAAoCX,wBAAwBM;AAqBpF;;;;;;;;;;;AAWA;;;;;;;;;iBAXwBM,qBAAAA,MAA2BtB;;;;;;;;;;;iBAW3BuB,8BAAAA,QAAsCb"}