@panoptic-eng/sdk 1.0.37 → 1.0.39

package/dist/index-Zvu-rJpV.d.ts

@@ -1,261 +0,0 @@
-import { TokenIdLeg } from "./position-BqIgubs5.js";
-
-//#region src/panoptic/v2/greeks/index.d.ts
-/**
-* 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).
-*/
-
-/**
- * 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 as calculatePortfolioDelta$1, calculatePortfolioGamma as calculatePortfolioGamma$1, calculatePortfolioGreeks as calculatePortfolioGreeks$1, calculatePortfolioValue as calculatePortfolioValue$1, calculatePositionDelta as calculatePositionDelta$1, calculatePositionDeltaDebtOnly as calculatePositionDeltaDebtOnly$1, calculatePositionDeltaWithSwap as calculatePositionDeltaWithSwap$1, calculatePositionGamma as calculatePositionGamma$1, calculatePositionGreeks as calculatePositionGreeks$1, calculatePositionValue as calculatePositionValue$1, getLegDelta as getLegDelta$1, getLegDeltaInVaultFrame as getLegDeltaInVaultFrame$1, getLegGamma as getLegGamma$1, getLegNetValueWidth0 as getLegNetValueWidth0$1, getLegValue as getLegValue$1, getLoanEffectiveDelta as getLoanEffectiveDelta$1, isCall as isCall$1, isDefinedRisk as isDefinedRisk$1, toVaultFrameAtTick as toVaultFrameAtTick$1 };
-//# sourceMappingURL=index-Zvu-rJpV.d.ts.map

package/dist/index-Zvu-rJpV.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Zvu-rJpV.d.ts","names":["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/greeks/index.d.ts"],"sourcesContent":null,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA;;;;;;;;AAQA;;;;;;iBARwBC,oBAAAA,MAA0BD;AAelD;;;;AAAgD;;;iBAPxBE,MAAAA;;;;;;;iBAOAC,aAAAA,OAAoBC,KAAKJ;;;;;;;;AAkBjD;;;;;;;;;;iBAAwBK,WAAAA,MAAiBL;;;;;;;;;AAmBzC;;AAEA;;;;;;;AAOA;iBATwBM,WAAAA,MAAiBN;;iBAEjBO,kBAAAA;;;;;;;iBAOAC,uBAAAA,MAA6BR;;;;;;;;;;;;AAsBrD;;;;AAIA;;;;AAwBA;;iBA5BwBS,WAAAA,MAAiBT;;AAgCzC;;UA5BiBU,mBAAAA;;QAEPV;;;;;;;;EAsCca,eAAAA,EAAAA,MAAAA;EAA8B;EAAA,UAAaH,CAAAA,EAAAA,MAAAA;EAAmB;AAApB;;;;AAMlE;;;;AAIA;;iBA1BwBC,sBAAAA,QAA8BD;;AAqCtD;;AAAuDA,iBAjC/BE,sBAAAA,CAiC+BF,KAAAA,EAjCDA,mBAiCCA,CAAAA,EAAAA,MAAAA;;AAA0C;;;;;;;;;;iBArBzEG,8BAAAA,QAAsCC,KAAKJ;;AAiCnE,CAAA,CAAA,EAAwBQ,MAAAA;;;;iBA3BAH,sBAAAA,QAA8BL;;;;UAIrCM,oBAAAA;;EAiCOG,KAAAA,EAAAA,MAAAA;;;;;;;;;iBAtBAF,uBAAAA,QAA+BP,sBAAsBM;AAgC7E;;;;AAIA;;;;AAAwG;;;iBAxBhFE,uBAAAA,YAAmCR;;;;;;;;;;iBAUnCS,uBAAAA,YAAmCT;;;;;;;;AAmC3D;;iBAzBwBU,uBAAAA,YAAmCV;;;;iBAInCW,wBAAAA,YAAoCX,wBAAwBM;;;;;AAgCpF;;;;;;;;;;;;;;;;iBAXwBM,qBAAAA,MAA2BtB;;;;;;;;;;;iBAW3BuB,8BAAAA,QAAsCb"}