@panoptic-eng/sdk 1.0.37 → 1.0.39

package/dist/{irm-DnM96-X4.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, getPositions$1 as getPositions, panopticPoolV2Abi, riskEngineAbi } from "./position-C8rkkKhi.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";
@@ -2317,11 +2317,13 @@ var _1 = {
 	},
 	"panoptic": {
 		"pool": {
+			"version": "v4",
 			"panopticPool": "0x00000000563b70d704f4c6675a5f6ac989fbae13",
 			"collateralTracker0": "0x1e46b0289B7E0F710E2Db8Ab87800dd782D624f7",
 			"collateralTracker1": "0x12bF31955522BAC337D93e1bC0a39F68D8BDa216"
 		},
 		"additionalPools": { "ethUsdc5bpsV3": {
+			"version": "v3",
 			"panopticPool": "0x00000000009C7B687e833559e34503f64d7ed7c4",
 			"collateralTracker0": "0x3CCdA7d5E841d6543D90BcEc20b36a724C184DE9",
 			"collateralTracker1": "0x69E9f9e44E5F52237493b980dd7306198C64A4E4"
@@ -2396,6 +2398,7 @@ var _8453 = {
 	},
 	"panoptic": {
 		"pool": {
+			"version": "v4",
 			"panopticPool": "0xB50e8bb68f5855DA742f4579274902a20454174a",
 			"collateralTracker0": "0x0d82b189c96EbB1f44A7207e6A9cfB1e490f2869",
 			"collateralTracker1": "0x9ba1082Ab3cb9edEA988697A14BBe543A3dABEd2"
@@ -2458,6 +2461,7 @@ var _11155111 = {
 	},
 	"panoptic": {
 		"pool": {
+			"version": "v4",
 			"panopticPool": "0x872b98C46b2062F663BEb2CC9D4cE046Da2a2918",
 			"collateralTracker0": "0x09a60b78d06a03e5148faedd3bfee6f58b22012f",
 			"collateralTracker1": "0x7365664c8101ff7e9422ae2b203822253c31e69c"
@@ -3001,5 +3005,4 @@ async function getIrmCurve(params) {
 }
 
 //#endregion
-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$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, getChainDeployment, getCollateralAddresses as getCollateralAddresses$1, getCollateralData as getCollateralData$1, getCurrentRates as getCurrentRates$1, getEthUsdcMarket, getInterestState as getInterestState$1, getIrmCurrent, getIrmCurve, getLiquidationPrices as getLiquidationPrices$1, getNetLiquidationValue as getNetLiquidationValue$1, getNetLiquidationValues as getNetLiquidationValues$1, isLiquidatable as isLiquidatable$1, isSupportedChain, packMarketState, panopticQueryAbi, parseTokenAmount as parseTokenAmount$1, parseWad as parseWad$1, ratePerSecWadToAprPct, readBlockAndAggregate, requireChainDeployment, requireReturnData, resolveVaultDisplayName, utilizationBpsToWad, utilizationPctToWad };
-//# sourceMappingURL=irm-DnM96-X4.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,3 +1,277 @@
-import "../../../position-BqIgubs5.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-Zvu-rJpV.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"}