@panoptic-eng/sdk 1.0.38 → 1.0.40

package/dist/index-Bo9tHtD7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Bo9tHtD7.d.ts","names":["BlockMeta","MintBufferRatio","tickToSqrtPriceX96","tickToPrice","tickToPriceDecimalScaled","sqrtPriceX96ToPriceDecimalScaled","priceToTick","sqrtPriceX96ToTick","formatTick","getPricesAtTick","formatTickRange","formatPriceRange","getTickSpacing","roundToTickSpacing","TickLimitsResult","tickLimits","OracleState","OracleEmaPeriods","OracleRiskParameters","OracleSafeModeCause","OracleSafeModeDiagnosis","DiagnosticOracleState","Pick","decodeOracleRiskParameters","diagnoseOracleSafeMode","Address","PublicClient","tickToSqrtPriceX96","BlockMeta","OracleState","Pool","RiskParameters","Utilization","OracleRiskParameters","PoolMetadata","GetPoolMetadataParams","getPoolMetadata","Promise","GetPoolParams","getPool","GetUtilizationParams","getUtilization","GetOracleStateParams","getOracleState","GetOracleRiskParametersParams","OracleRiskParametersState","getOracleRiskParameters","GetRiskParametersParams","getRiskParameters","validateBuilderCode","FetchPoolIdParams","FetchPoolIdResult","fetchPoolId","Address","PoolMetadata","BlockMeta","PoolHealthStatus","CollateralTracker","RiskEngine","PoolKey","Pool","Utilization","Address","BlockMeta","TokenIdLeg","Position","LegGreeksParams","PositionGreeks","ClosedPosition","RealizedPnL","StoredPositionData","StoredPoolMeta","Address","BlockMeta","Pool","PoolHealthStatus","Position","PositionGreeks","TokenCollateral","AccountCollateral","AccountSummaryBasic","AccountSummaryRisk","LiquidationPrices","NetLiquidationValue","NetLiquidationValues","CollateralEstimate","BlockMeta","MintBufferRatio","SafeMode","OracleState","SafeModeState","RiskParameters","CurrentRates","Address","Hash","PanopticEventType","BaseEvent","OptionMintedEvent","OptionBurntEvent","AccountLiquidatedEvent","ForcedExercisedEvent","PremiumSettledEvent","DepositEvent","WithdrawEvent","BorrowRateUpdatedEvent","LiquidityChunkUpdatedEvent","ProtocolLossRealizedEvent","ModifyLiquidityEvent","SwapEvent","DonateEvent","PanopticEvent","LegUpdate","EventSubscription","SyncEvent","Address","Hash","PanopticEvent","TxResult","TxReceipt","Promise","TxResultWithReceipt","TxBroadcaster","TxOverrides","NonceManager","DispatchCall","PanopticError","Error","PanopticError","BlockMeta","Position","PositionGreeks","TokenFlow","SimulationResult","T","OpenPositionSimulation","ClosePositionSimulation","ForceExerciseSimulation","LiquidateSimulation","SettleSimulation","DepositSimulation","WithdrawSimulation","DispatchSimulation","Address","Hash","ChunkSpread","ChunkKey","ChunkData","ChunkMetadata","ChunkStats","Address","V3PoolConfig","V4PoolConfig","PoolVersionConfig","Address","Hash","SyncStatus","SyncState","SyncCheckpoint","SyncOptions","SyncResult","ReorgDetection"],"sources":["../src/panoptic/v2/types/meta.d.ts","../src/panoptic/v2/types/mintBuffer.d.ts","../src/panoptic/v2/formatters/tick.d.ts","../src/panoptic/v2/utils/oracleSafeMode.d.ts","../src/panoptic/v2/reads/pool.d.ts","../src/panoptic/v2/types/pool.d.ts","../src/panoptic/v2/types/position.d.ts","../src/panoptic/v2/types/account.d.ts","../src/panoptic/v2/types/oracle.d.ts","../src/panoptic/v2/types/events.d.ts","../src/panoptic/v2/types/tx.d.ts","../src/panoptic/v2/errors/base.d.ts","../src/panoptic/v2/types/simulation.d.ts","../src/panoptic/v2/types/chunks.d.ts","../src/panoptic/v2/types/poolConfig.d.ts","../src/panoptic/v2/types/sync.d.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/index-CttjEZ-S.d.ts

@@ -1,275 +0,0 @@
-import { PanopticError, SimulationResult, TxResult } from "./index-Bo9tHtD7.js";
-import { ApproveErc20ForCowParams, CancelCowOrderParams, CheckCowApprovalParams, CowApprovalStatus, CowOrderResult, CowOrderState, CowQuote, GetCowOrderStatusParams, QuoteCowSwapParams, SignAndSubmitCowOrderParams } from "./types-DM0nxlZr.js";
-import { Address } from "viem";
-
-//#region src/cow/addresses.d.ts
-/** GPv2Settlement — EIP-712 verifying contract for signed orders. */
-
-/** GPv2Settlement — EIP-712 verifying contract for signed orders. */
-declare const COW_SETTLEMENT: Address;
-/** GPv2VaultRelayer — the ERC20 approval target (NOT the settlement contract). */
-declare const COW_VAULT_RELAYER: Address;
-/**
- * Buy-token marker for native ETH. Orders buying this sentinel settle in
- * native ETH (the settlement contract unwraps WETH). Only valid on the buy
- * side — selling native ETH requires the eth-flow contract (unsupported here).
- */
-declare const COW_NATIVE_ETH: Address;
-/** Order-book API base URL per chain. */
-declare const COW_API_URLS: Partial<Record<number, string>>;
-/** Whether CoW Protocol has an order book for the chain. */
-declare function isCowSupportedChain(chainId: bigint | number): boolean;
-
-//#endregion
-//#region src/cow/approval.d.ts
-/** Check whether the vault relayer can pull `amount` of the sell token. */
-declare function checkCowApproval(params: CheckCowApprovalParams): Promise<CowApprovalStatus>;
-/** Approve the sell token to the vault relayer (defaults to unlimited). */
-declare function approveErc20ForCow(params: ApproveErc20ForCowParams): Promise<TxResult>;
-
-//#endregion
-//#region src/cow/compare.d.ts
-/**
- * Venue selection between the Uniswap v4 router and CoW Swap.
- *
- * Pure amount comparison so it stays testable and reusable outside React.
- * Gas cost of the router tx is not factored in (CoW ERC20 sells are gasless);
- * TODO: optionally discount the Uniswap side by gasEstimate × gas price.
- *
- * @module cow/compare
- */
-/** Swap venues the UI can route through. */
-type SwapVenue = 'uniswap' | 'cow';
-/** Parameters for {@link pickBestVenue}. */
-interface PickBestVenueParams {
-  /** 'sell' = exact-in (maximize output), 'buy' = exact-out (minimize input). */
-  kind: 'sell' | 'buy';
-  /** Uniswap quote amounts; omit when the quote failed or is unavailable. */
-  uniswap?: {
-    /** Quoted output (exact-in). */
-    amountOut?: bigint;
-    /** Quoted input (exact-out). */
-    amountIn?: bigint;
-  };
-  /** CoW quote amounts; omit when the quote failed or is unavailable. */
-  cow?: {
-    /** Quoted net output (exact-in). */
-    buyAmount?: bigint;
-    /** Quoted gross input including fee (exact-out). */
-    sellAmountTotal?: bigint;
-  };
-}
-/** Result of {@link pickBestVenue}. */
-interface BestVenue {
-  winner: SwapVenue;
-  /** Price advantage of the winner over the loser in bps (only when both quoted). */
-  advantageBps?: bigint;
-}
-/**
- * Pick the venue with the better effective price. Exact-in compares net
- * output (higher wins); exact-out compares gross input (lower wins). With a
- * single usable quote that venue wins; ties go to Uniswap (instant
- * settlement); with no usable quotes Uniswap wins by default.
- */
-declare function pickBestVenue(params: PickBestVenueParams): BestVenue;
-
-//#endregion
-//#region src/cow/eip712.d.ts
-/** GPv2 `Order` struct, in EIP-712 typed-data form. */
-declare const COW_ORDER_TYPES: {
-  readonly Order: readonly [{
-    readonly name: "sellToken";
-    readonly type: "address";
-  }, {
-    readonly name: "buyToken";
-    readonly type: "address";
-  }, {
-    readonly name: "receiver";
-    readonly type: "address";
-  }, {
-    readonly name: "sellAmount";
-    readonly type: "uint256";
-  }, {
-    readonly name: "buyAmount";
-    readonly type: "uint256";
-  }, {
-    readonly name: "validTo";
-    readonly type: "uint32";
-  }, {
-    readonly name: "appData";
-    readonly type: "bytes32";
-  }, {
-    readonly name: "feeAmount";
-    readonly type: "uint256";
-  }, {
-    readonly name: "kind";
-    readonly type: "string";
-  }, {
-    readonly name: "partiallyFillable";
-    readonly type: "bool";
-  }, {
-    readonly name: "sellTokenBalance";
-    readonly type: "string";
-  }, {
-    readonly name: "buyTokenBalance";
-    readonly type: "string";
-  }];
-};
-/** GPv2 order-cancellation struct (batch of order UIDs). */
-declare const COW_CANCELLATION_TYPES: {
-  readonly OrderCancellations: readonly [{
-    readonly name: "orderUids";
-    readonly type: "bytes[]";
-  }];
-};
-/** EIP-712 domain for GPv2Settlement on the given chain. */
-declare function cowDomain(chainId: bigint | number): {
-  name: string;
-  version: string;
-  chainId: number;
-  verifyingContract: Address;
-};
-/**
- * Full appData JSON document attached to orders. The order itself carries only
- * its keccak256 hash; the API stores the document when it accompanies the
- * order POST. Must stay byte-identical to {@link APP_DATA_HASH}.
- */
-declare const APP_DATA_DOC = "{\"appCode\":\"panoptic\",\"metadata\":{},\"version\":\"1.3.0\"}";
-/** keccak256 of {@link APP_DATA_DOC} — the `appData` field signed in the order. */
-declare const APP_DATA_HASH: `0x${string}`;
-
-//#endregion
-//#region src/cow/errors.d.ts
-/** The chain has no CoW order book. */
-declare class CowUnsupportedChainError extends PanopticError {
-  readonly chainId: bigint;
-  readonly name = "CowUnsupportedChainError";
-  constructor(chainId: bigint, cause?: Error);
-}
-/** The order-book API rejected a request (non-2xx response). */
-declare class CowApiError extends PanopticError {
-  /** Machine-readable API error type, e.g. 'SellAmountDoesNotCoverFee'. */
-  readonly errorType: string;
-  readonly status: number;
-  readonly name: string;
-  constructor(/** Machine-readable API error type, e.g. 'SellAmountDoesNotCoverFee'. */
-  errorType: string, message: string, status: number, cause?: Error);
-}
-/** The sell amount is too small to cover the protocol fee (dust order). */
-declare class CowOrderTooSmallError extends CowApiError {
-  readonly name = "CowOrderTooSmallError";
-  constructor(message: string, status: number, cause?: Error);
-}
-/** Selling native ETH requires the eth-flow contract (unsupported here); buying it is fine. */
-declare class CowNativeTokenError extends PanopticError {
-  readonly name = "CowNativeTokenError";
-  constructor(cause?: Error);
-}
-
-//#endregion
-//#region src/cow/order.d.ts
-/**
- * Build the final order from a quote, sign it (EIP-712) and POST it to the
- * order book. The signed `feeAmount` is 0 — the fee is already folded into the
- * quote's `orderSellAmount`.
- */
-declare function signAndSubmitCowOrder(params: SignAndSubmitCowOrderParams): Promise<CowOrderResult>;
-/**
- * Cancel an open order off-chain (free, signed cancellation). Cancellation is
- * best-effort: an order already committed to a solver batch can still settle.
- */
-declare function cancelCowOrder(params: CancelCowOrderParams): Promise<void>;
-
-//#endregion
-//#region src/cow/quote.d.ts
-/** Default order validity window (30 minutes). */
-declare const DEFAULT_VALID_FOR_SECONDS = 1800n;
-/**
- * Quote a swap via the CoW order book.
- *
- * For `kind: 'sell'` (exact-in) `amount` is the sell amount before fee; for
- * `kind: 'buy'` (exact-out) it is the exact buy amount. The returned
- * `orderSellAmount`/`orderBuyAmount` are ready to sign: the fee is folded into
- * the sell side (orders are placed with `feeAmount: 0` under the current fee
- * model) and `slippageBps` is applied to the non-exact side.
- */
-declare function quoteCowSwap(params: QuoteCowSwapParams): Promise<SimulationResult<CowQuote>>;
-
-//#endregion
-//#region src/cow/status.d.ts
-/**
- * Fetch an order's lifecycle state. Once any trade has executed, the
- * settlement tx hash is included (fetched from the trades endpoint).
- */
-declare function getCowOrderStatus(params: GetCowOrderStatusParams): Promise<CowOrderState>;
-
-//#endregion
-//#region src/cow/tokens.d.ts
-/** Resolved token-list entry. */
-interface CowTokenInfo {
-  chainId: number;
-  address: Address;
-  symbol: string;
-  name: string;
-  decimals: number;
-  logoURI?: string;
-}
-/** Parameters for {@link findCowToken}. */
-interface FindCowTokenParams {
-  /** Chain to resolve on. */
-  chainId: bigint;
-  /** Token symbol, case-insensitive (e.g. 'nvdax'). */
-  symbol: string;
-  /** Override the token-list URLs (e.g. tests). */
-  listUrls?: string[];
-}
-/**
- * Find a token by symbol on the given chain across CoW's token lists. The
- * first list containing a (case-insensitive) symbol match wins; within a
- * list the first match wins, which favors canonical entries on collisions.
- * Returns null when no list resolves the symbol (or all fetches fail).
- *
- * Resolution only proves the token is listed — whether solvers can actually
- * fill a given pair/size is answered by `quoteCowSwap`.
- */
-declare function findCowToken(params: FindCowTokenParams): Promise<CowTokenInfo | null>;
-
-//#endregion
-//#region src/cow/xstockWrappers.generated.d.ts
-declare const XSTOCK_WRAPPERS: XstockWrapperRegistry;
-
-//#endregion
-//#region src/cow/xstockWrappers.d.ts
-/** A single xStock → wrapper mapping entry. */
-interface XstockWrapperInfo {
-  /** ERC4626 wrapper (the token Panoptic/Uniswap pools trade). */
-  wrapper: Address;
-  /** Underlying rebasing xStock (`asset()` of the wrapper; the CoW-traded token). */
-  underlying: Address;
-  /** Wrapper symbol, e.g. `wNVDAx`. */
-  symbol: string;
-  /** Wrapper name, e.g. `Wrapped NVIDIA xStock`. */
-  name: string;
-  /** Wrapper (and underlying) ERC20 decimals. */
-  decimals: number;
-}
-/** Generated registry keyed by chainId. */
-type XstockWrapperRegistry = Partial<Record<number, XstockWrapperInfo[]>>;
-/**
- * Resolve the wrapper for an unwrapped xStock. Returns `undefined` when the
- * address isn't a known xStock underlying on this chain.
- */
-declare function getXstockWrapper(chainId: number, underlying: Address): XstockWrapperInfo | undefined;
-/**
- * Resolve the underlying xStock for a wrapper address. Returns `undefined` when
- * the address isn't a known xStock wrapper on this chain.
- */
-declare function getXstockUnderlying(chainId: number, wrapper: Address): XstockWrapperInfo | undefined;
-/** True if `address` is a known unwrapped xStock on this chain. */
-declare function isXstockUnderlying(chainId: number, address: Address): boolean;
-/** True if `address` is a known xStock wrapper on this chain. */
-declare function isXstockWrapper(chainId: number, address: Address): boolean;
-
-//#endregion
-export { APP_DATA_DOC as APP_DATA_DOC$1, APP_DATA_HASH as APP_DATA_HASH$1, BestVenue, COW_API_URLS as COW_API_URLS$1, COW_CANCELLATION_TYPES as COW_CANCELLATION_TYPES$1, COW_NATIVE_ETH as COW_NATIVE_ETH$1, COW_ORDER_TYPES as COW_ORDER_TYPES$1, COW_SETTLEMENT as COW_SETTLEMENT$1, COW_VAULT_RELAYER as COW_VAULT_RELAYER$1, CowApiError as CowApiError$1, CowNativeTokenError as CowNativeTokenError$1, CowOrderTooSmallError as CowOrderTooSmallError$1, CowTokenInfo, CowUnsupportedChainError as CowUnsupportedChainError$1, DEFAULT_VALID_FOR_SECONDS as DEFAULT_VALID_FOR_SECONDS$1, FindCowTokenParams, PickBestVenueParams, SwapVenue, XSTOCK_WRAPPERS as XSTOCK_WRAPPERS$1, XstockWrapperInfo, XstockWrapperRegistry, approveErc20ForCow as approveErc20ForCow$1, cancelCowOrder as cancelCowOrder$1, checkCowApproval as checkCowApproval$1, cowDomain as cowDomain$1, findCowToken as findCowToken$1, getCowOrderStatus as getCowOrderStatus$1, getXstockUnderlying as getXstockUnderlying$1, getXstockWrapper as getXstockWrapper$1, isCowSupportedChain as isCowSupportedChain$1, isXstockUnderlying as isXstockUnderlying$1, isXstockWrapper as isXstockWrapper$1, pickBestVenue as pickBestVenue$1, quoteCowSwap as quoteCowSwap$1, signAndSubmitCowOrder as signAndSubmitCowOrder$1 };
-//# sourceMappingURL=index-CttjEZ-S.d.ts.map

package/dist/index-CttjEZ-S.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CttjEZ-S.d.ts","names":["Address","COW_SETTLEMENT","COW_VAULT_RELAYER","COW_NATIVE_ETH","COW_API_URLS","Record","Partial","isCowSupportedChain","TxResult","ApproveErc20ForCowParams","CheckCowApprovalParams","CowApprovalStatus","checkCowApproval","Promise","approveErc20ForCow","SwapVenue","PickBestVenueParams","BestVenue","pickBestVenue","Address","COW_ORDER_TYPES","COW_CANCELLATION_TYPES","cowDomain","APP_DATA_DOC","APP_DATA_HASH","PanopticError","CowUnsupportedChainError","Error","CowApiError","CowOrderTooSmallError","CowNativeTokenError","CancelCowOrderParams","CowOrderResult","SignAndSubmitCowOrderParams","signAndSubmitCowOrder","Promise","cancelCowOrder","SimulationResult","CowQuote","QuoteCowSwapParams","DEFAULT_VALID_FOR_SECONDS","quoteCowSwap","Promise","CowOrderState","GetCowOrderStatusParams","getCowOrderStatus","Promise","Address","CowTokenInfo","FindCowTokenParams","findCowToken","Promise","XstockWrapperRegistry","XSTOCK_WRAPPERS","Address","XSTOCK_WRAPPERS","XstockWrapperInfo","XstockWrapperRegistry","Record","Partial","getXstockWrapper","getXstockUnderlying","isXstockUnderlying","isXstockWrapper"],"sources":["../src/cow/addresses.d.ts","../src/cow/approval.d.ts","../src/cow/compare.d.ts","../src/cow/eip712.d.ts","../src/cow/errors.d.ts","../src/cow/order.d.ts","../src/cow/quote.d.ts","../src/cow/status.d.ts","../src/cow/tokens.d.ts","../src/cow/xstockWrappers.generated.d.ts","../src/cow/xstockWrappers.d.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/index-DktZq9Kb.d.ts

@@ -1,261 +0,0 @@
-import { TokenIdLeg } from "./index-Bo9tHtD7.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-DktZq9Kb.d.ts.map

package/dist/index-DktZq9Kb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DktZq9Kb.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"}