@panoptic-eng/sdk 1.0.44 → 1.0.46

package/dist/panoptic/v2/react-public.d.ts

@@ -82,6 +82,16 @@ declare const MIN_TICK = -887272n;
  * Maximum tick value for Uniswap v3/v4 pools.
  */
 declare const MAX_TICK = 887272n;
+/**
+ * PanopticQuery sentinel indicating that no lower liquidation boundary exists.
+ * This is int24.min, not Uniswap's minimum usable tick.
+ */
+declare const NO_LOWER_LIQUIDATION_TICK: bigint;
+/**
+ * PanopticQuery sentinel indicating that no upper liquidation boundary exists.
+ * This is int24.max, not Uniswap's maximum usable tick.
+ */
+declare const NO_UPPER_LIQUIDATION_TICK: bigint;
 /**
  * Basis points denominator (100% = 10000 bps).
  */
@@ -1081,11 +1091,13 @@ interface NetLiquidationValues {
  * Liquidation prices result.
  */
 interface LiquidationPrices {
-  /** Lower liquidation tick (null if position is safe at MIN_TICK) */
+  /** Lower liquidation tick (null when PanopticQuery reports no lower boundary) */
   lowerTick: bigint | null;
-  /** Upper liquidation tick (null if position is safe at MAX_TICK) */
+  /** Upper liquidation tick (null when PanopticQuery reports no upper boundary) */
   upperTick: bigint | null;
-  /** Whether the account is currently liquidatable */
+  /** Whether either liquidation boundary exists. This does not indicate current insolvency. */
+  hasLiquidationBoundary: boolean;
+  /** @deprecated Use hasLiquidationBoundary. This does not indicate current insolvency. */
   isLiquidatable: boolean;
   /** Block metadata */
   _meta: BlockMeta;
@@ -2856,6 +2868,23 @@ interface ForceExerciseSimulation {
   /** Reason if cannot exercise */
   reason?: string;
 }
+/**
+ * Settle-premium-on-another-account simulation result data.
+ */
+interface SettlePremiumFromSimulation {
+  /** Short premium the settle makes available to the caller (token 0) */
+  premium0: bigint;
+  /** Short premium the settle makes available to the caller (token 1) */
+  premium1: bigint;
+  /** Total premium the buyer pays into the chunk (token 0) */
+  settled0: bigint;
+  /** Total premium the buyer pays into the chunk (token 1) */
+  settled1: bigint;
+  /** Whether the settlement would succeed */
+  canSettle: boolean;
+  /** Reason if cannot settle */
+  reason?: string;
+}
 /**
  * Liquidation simulation result data.
  */
@@ -2924,6 +2953,10 @@ interface DispatchSimulation {
   netAmount0: bigint;
   /** Token 1 net change */
   netAmount1: bigint;
+  /** Premia settled for token 0 (null when atomic pre/post position reads are unavailable). */
+  premiaReceived0: bigint | null;
+  /** Premia settled for token 1 (null when atomic pre/post position reads are unavailable). */
+  premiaReceived1: bigint | null;
   /** Positions created */
   positionsCreated: bigint[];
   /** Positions closed */
@@ -3926,6 +3959,66 @@ declare function deriveUniqueTokenId(params: DeriveUniqueTokenIdParams): DeriveU
  */
 declare function planDeriveStrategy(baseTokenId: bigint): DeriveStrategy;
 
+//#endregion
+//#region src/panoptic/v2/tokenId/generateOverlapping.d.ts
+type OverlappingOptionType = 'call' | 'put';
+/** One option leg repeated at every generated strike. */
+interface OverlappingOptionLegConfig {
+  optionType: OverlappingOptionType;
+  optionRatio: bigint;
+  isLong: boolean;
+  /** Defaults to this leg's index. */
+  riskPartner?: bigint;
+}
+/** Parameters for {@link generateOverlappingTokenIds}. */
+interface GenerateOverlappingTokenIdsParams {
+  /** Encoded 64-bit Panoptic pool ID, including tick spacing. */
+  poolId: bigint;
+  /** Current Uniswap pool tick. */
+  currentTick: bigint;
+  /** Standard option timescale used to derive every leg's width. */
+  timescale: Timescale;
+  /** Positive quote-token price interval, such as "25" or "50". */
+  strikePriceSpacing: string;
+  /** Asset token index in the pool (0 or 1). */
+  asset: bigint;
+  assetDecimals: bigint;
+  quoteDecimals: bigint;
+  /** One to four call/put legs sharing each generated strike. */
+  legs: readonly OverlappingOptionLegConfig[];
+  /** Total size divided across all generated TokenIds. */
+  positionSize: bigint;
+}
+/** TokenIds and sizes aligned with the corresponding `dispatch()` arguments. */
+interface GenerateOverlappingTokenIdsResult {
+  positionIdList: bigint[];
+  positionSizes: bigint[];
+}
+/**
+ * Generate a fixed quote-price lattice of co-strike TokenIds whose liquidity
+ * ranges strictly contain the current tick. Returned arrays are ordered by
+ * ascending quote strike price and are ready for `dispatch()`.
+ */
+declare function generateOverlappingTokenIds(params: GenerateOverlappingTokenIdsParams): GenerateOverlappingTokenIdsResult;
+
+//#endregion
+//#region src/panoptic/v2/tokenId/split.d.ts
+/** TokenIds and sizes aligned with the corresponding `dispatch()` arguments. */
+interface SplitTokenIdByTimescaleResult {
+  positionIdList: bigint[];
+  positionSizes: bigint[];
+}
+/**
+ * Split every standalone option, economic straddle, or mutual risk pair in a
+ * TokenId into a shorter standard timescale. Width-zero credit/loan legs are
+ * emitted together as one final position. Returned arrays are parallel and
+ * ready for `dispatch()`.
+ *
+ * Each option group divides `positionSize` independently across its children.
+ * Integer remainder units are assigned to the lower children first.
+ */
+declare function splitTokenIdByTimescale(tokenId: bigint, positionSize: bigint, targetTimescale: Timescale): SplitTokenIdByTimescaleResult;
+
 //#endregion
 //#region src/panoptic/v2/sfpmSwap/types.d.ts
 /** Exact-input or exact-output swap. */
@@ -4607,6 +4700,54 @@ interface GetPositionsWithPremiaParams {
  * ```
  */
 declare function getPositionsWithPremia(params: GetPositionsWithPremiaParams): Promise<PositionsWithPremiaResult>;
+/**
+ * Forfeitable (unsettled) short premium on a position.
+ */
+interface ForfeitablePremium {
+  /** Short premium owed to the account, including unsettled pending premium (token 0) */
+  owed0: bigint;
+  /** Short premium owed to the account, including unsettled pending premium (token 1) */
+  owed1: bigint;
+  /** Short premium currently available to collect (token 0) */
+  available0: bigint;
+  /** Short premium currently available to collect (token 1) */
+  available1: bigint;
+  /** Premium that would be forfeited if the position were closed now (owed - available, token 0) */
+  forfeit0: bigint;
+  /** Premium that would be forfeited if the position were closed now (owed - available, token 1) */
+  forfeit1: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Parameters for getForfeitablePremium.
+ */
+interface GetForfeitablePremiumParams {
+  /** viem PublicClient */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Account address (the seller) */
+  account: Address$1;
+  /** TokenIds to measure (typically the position(s) being closed) */
+  tokenIds: bigint[];
+  /** Optional block number for historical queries */
+  blockNumber?: bigint;
+}
+/**
+ * Get the unsettled short premium an account would forfeit by closing now.
+ *
+ * Calls `getFullPositionsData` twice in one multicall — once with
+ * `includePendingPremium = true` (everything owed to the short legs) and once
+ * with `false` (only what is available to collect). The difference is the
+ * premium still owed by buyers that has not been settled; closing before it
+ * settles forfeits it. Settling buyers first (see `settlePremiumFrom`) moves
+ * that premium into the available bucket.
+ *
+ * @param params - The parameters
+ * @returns Owed, available, and forfeitable premium with block metadata
+ */
+declare function getForfeitablePremium(params: GetForfeitablePremiumParams): Promise<ForfeitablePremium>;
 
 //#endregion
 //#region src/panoptic/v2/reads/account.d.ts
@@ -6663,9 +6804,9 @@ interface MarginBuffer {
   denominatedInToken: 0 | 1;
   /** Tick distance to nearest liquidation boundary (null if no liquidation boundaries) */
   liquidationDistance: bigint | null;
-  /** Lower liquidation tick (null if safe at MIN_TICK) */
+  /** Lower liquidation tick (null for the PanopticQuery NO_LOWER_LIQUIDATION_TICK sentinel) */
   lowerLiquidationTick: bigint | null;
-  /** Upper liquidation tick (null if safe at MAX_TICK) */
+  /** Upper liquidation tick (null for the PanopticQuery NO_UPPER_LIQUIDATION_TICK sentinel) */
   upperLiquidationTick: bigint | null;
   /**
    * Collateral usage against the constraint that actually liquidates, in bps
@@ -9221,6 +9362,8 @@ interface LiquidateParams {
   positionIdListToFinal: bigint[];
   /** Packed value for using premia as collateral */
   usePremiaAsCollateral?: bigint;
+  /** Native currency supplied to cover a negative token0 liquidation bonus */
+  value?: bigint;
   /** Gas and transaction overrides */
   txOverrides?: TxOverrides;
 }
@@ -9318,6 +9461,231 @@ declare function forceExercise(params: ForceExerciseParams): Promise<TxResult>;
  */
 declare function forceExerciseAndWait(params: ForceExerciseParams): Promise<TxReceipt>;
 
+//#endregion
+//#region src/panoptic/v2/writes/settlePremiumFrom.d.ts
+/**
+ * Reorder a position ID list so `tokenId` is the last element.
+ *
+ * The position list fingerprint is an XOR hash, so ordering is free to change.
+ * The contract settles premium on the last element of `positionIdListTo`.
+ *
+ * @throws PanopticError if `tokenId` is not in the list
+ */
+declare function orderListForSettle(positionIdList: bigint[], tokenId: bigint): bigint[];
+/**
+ * Parameters for settling another account's long premium.
+ */
+interface SettlePremiumFromParams {
+  /** Public client */
+  client: PublicClient;
+  /** Wallet client */
+  walletClient: WalletClient;
+  /** Caller (settler) account address */
+  account: Address$1;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Account whose long premium is being settled */
+  user: Address$1;
+  /** Position IDs from the caller's account (full held list) */
+  positionIdListFrom: bigint[];
+  /** The target user's full held position ID list (passed as both To and ToFinal) */
+  positionIdList: bigint[];
+  /**
+   * The target position to settle premium on. The contract settles the LAST
+   * element of the list; when provided, the list is reordered to end with
+   * this tokenId. When omitted, the last element of `positionIdList` is settled.
+   */
+  tokenId?: bigint;
+  /** Packed value for using premia as collateral */
+  usePremiaAsCollateral?: bigint;
+  /** Gas and transaction overrides */
+  txOverrides?: TxOverrides;
+  /** Storage adapter for auto-syncing positions after confirmation */
+  storage?: StorageAdapter;
+  /** Chain ID (required when storage is provided) */
+  chainId?: bigint;
+}
+/**
+ * Settle another account's accumulated long premium.
+ *
+ * Calls `dispatchFrom` with the target's position list passed as both
+ * `positionIdListTo` and `positionIdListToFinal` (equal lengths select the
+ * settle-premium mode and cannot force-exercise or liquidate). Requires the
+ * target account to be solvent; the settled premium is credited to the
+ * sellers of the corresponding chunks.
+ *
+ * @param params - Settle premium parameters
+ * @returns TxResult
+ *
+ * @example
+ * ```typescript
+ * const result = await settlePremiumFrom({
+ *   client,
+ *   walletClient,
+ *   account: sellerAddress,
+ *   poolAddress,
+ *   user: buyerAccount,
+ *   positionIdListFrom: sellerPositions,
+ *   positionIdList: buyerPositions,
+ * })
+ * const receipt = await result.wait()
+ * ```
+ */
+declare function settlePremiumFrom(params: SettlePremiumFromParams): Promise<TxResult>;
+/**
+ * Settle another account's premium and wait for confirmation.
+ *
+ * When `storage` and `chainId` are provided, automatically syncs the
+ * caller's positions after the transaction confirms.
+ */
+declare function settlePremiumFromAndWait(params: SettlePremiumFromParams): Promise<TxReceipt>;
+
+//#endregion
+//#region src/panoptic/v2/simulations/creditWrap.d.ts
+/**
+ * Pre-encoded `dispatch()` arguments a credit wrap is applied to.
+ *
+ * Alias of {@link BatchDispatchArgs} — the two are the same concept.
+ */
+type DispatchIntent = BatchDispatchArgs;
+/**
+ * Which side of the swap is exact.
+ *
+ * - `exact-out`: the credit **sources** a known amount of its token, paying a
+ *   swapped amount of the counter-token. Mint carries `swapAtMint=true`.
+ * - `exact-in`: the credit **sells** a known amount of its token, receiving a
+ *   swapped amount of the counter-token. Burn carries `swapAtMint=true`.
+ */
+type CreditWrapDirection = 'exact-in' | 'exact-out';
+/**
+ * Where the two credit legs sit relative to the user's own operations.
+ *
+ * - `straddle`: mint first, user ops, burn last. Required for `exact-out`, where
+ *   the sourced token must be available while the user's ops run.
+ * - `prepend`: both legs before the user's ops. Used by bootstrap recovery when
+ *   the account can sell one collateral token but holds none of the token it needs.
+ * - `append`: both legs after the user's ops, for flows where the token being
+ *   sold does not exist until those operations run.
+ */
+type CreditWrapPlacement = 'append' | 'prepend' | 'straddle';
+interface BuildCreditWrappedDispatchParams {
+  dispatch: DispatchIntent;
+  /** The temporary width=0 credit leg. */
+  creditTokenId: bigint;
+  /** Size of the mint leg. The burn leg always passes `0n` (= burn all). */
+  creditPositionSize: bigint;
+  tickLimitLow: bigint;
+  tickLimitHigh: bigint;
+  direction: CreditWrapDirection;
+  placement: CreditWrapPlacement;
+}
+/**
+ * Wrap a dispatch with a temporary credit leg that is opened and closed in the
+ * same transaction, netting to a swap.
+ *
+ * `swapAtMint` is not a calldata flag — it is the ORDER of the tick-limit pair:
+ * descending `[high, low]` turns the swap on, ascending `[low, high]` leaves it
+ * off. Exactly one of the two legs carries it, and which one is what makes the
+ * swap exact-in vs exact-out.
+ */
+declare function buildCreditWrappedDispatch(params: BuildCreditWrappedDispatchParams): DispatchIntent;
+
+//#endregion
+//#region src/panoptic/v2/writes/settleSequence.d.ts
+/**
+ * One buyer whose long premium is settled by the sequence.
+ */
+interface SettleSequenceTarget {
+  /** Account whose long premium is being settled */
+  user: Address$1;
+  /** The target user's full held position ID list */
+  positionIdList: bigint[];
+  /** The position to settle premium on (reordered to the end of the list) */
+  tokenId: bigint;
+}
+/**
+ * Optional close of the caller's own position appended to the sequence.
+ */
+interface SettleSequenceClose {
+  /** The caller's position to close */
+  tokenId: bigint;
+  /** The caller's position list after the close (excludes `tokenId`) */
+  finalPositionIdList: bigint[];
+  /** Lower tick limit */
+  tickLimitLow: bigint;
+  /** Upper tick limit */
+  tickLimitHigh: bigint;
+  /** Spread limit (default 0) */
+  spreadLimit?: bigint;
+  /** Whether to swap at mint/burn (descending tick limits). Default false */
+  swapAtMint?: boolean;
+  /** Whether to use premia as collateral for the close. Default false */
+  usePremiaAsCollateral?: boolean;
+  /** Builder code (default 0) */
+  builderCode?: bigint;
+}
+/**
+ * Parameters shared by the settle-sequence write and simulation.
+ */
+interface SettleSequenceCallsParams {
+  /** Position IDs from the caller's account (full held list) */
+  positionIdListFrom: bigint[];
+  /** Buyers to settle */
+  targets: SettleSequenceTarget[];
+  /** Optional close of the caller's own position, appended last */
+  close?: SettleSequenceClose;
+  /**
+   * Optional arbitrary dispatch appended last (e.g. a reduce-size mint+burn
+   * or a batch dispatch). Mutually exclusive with `close`.
+   */
+  dispatch?: DispatchIntent;
+  /** Packed value for using premia as collateral in the settles */
+  usePremiaAsCollateral?: bigint;
+}
+/**
+ * Build the encoded PanopticPool calls for a settle sequence: one settle-mode
+ * `dispatchFrom` per target (equal To/ToFinal lists, settled tokenId last),
+ * then the caller's own close `dispatch` when provided.
+ *
+ * A pure settle changes no position list, so targets need no cross-call
+ * bookkeeping (unlike a force-exercise sequence).
+ */
+declare function buildSettleSequenceCalls(params: SettleSequenceCallsParams): Hex[];
+/**
+ * Parameters for executing a settle sequence.
+ */
+interface ExecuteSettleSequenceParams extends SettleSequenceCallsParams {
+  /** Public client */
+  client: PublicClient;
+  /** Wallet client */
+  walletClient: WalletClient;
+  /** Caller (settler) account address */
+  account: Address$1;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Gas and transaction overrides */
+  txOverrides?: TxOverrides;
+  /** Storage adapter for auto-syncing positions after confirmation */
+  storage?: StorageAdapter;
+  /** Chain ID (required when storage is provided) */
+  chainId?: bigint;
+}
+/**
+ * Execute a settle sequence: settle each target buyer's owed long premium,
+ * then optionally close the caller's own position, in one multicall.
+ *
+ * @param params - Settle sequence parameters
+ * @returns TxResult
+ */
+declare function executeSettleSequence(params: ExecuteSettleSequenceParams): Promise<TxResult>;
+/**
+ * Execute a settle sequence and wait for confirmation.
+ *
+ * When `storage` and `chainId` are provided, automatically syncs the
+ * caller's positions after the transaction confirms.
+ */
+declare function executeSettleSequenceAndWait(params: ExecuteSettleSequenceParams): Promise<TxReceipt>;
+
 //#endregion
 //#region src/panoptic/v2/writes/settle.d.ts
 /**
@@ -10448,6 +10816,8 @@ interface SimulateDispatchParams {
   usePremiaAsCollateral?: boolean;
   /** Builder code */
   builderCode?: bigint;
+  /** Capture aggregate settled premia from atomic pre/post position snapshots. */
+  measurePremia?: boolean;
   /** Optional block number for simulation */
   blockNumber?: bigint;
 }
@@ -10651,6 +11021,129 @@ interface SimulateSettleParams {
  */
 declare function simulateSettle(params: SimulateSettleParams): Promise<SimulationResult<SettleSimulation>>;
 
+//#endregion
+//#region src/panoptic/v2/simulations/simulateSettlePremiumBatch.d.ts
+/**
+ * Per-target result of a batch settle simulation.
+ */
+interface SettlePremiumBatchTargetResult {
+  /** The simulated target */
+  target: SettleSequenceTarget;
+  /** The individual simulation outcome */
+  simulation: SettlePremiumFromSimulation;
+}
+/**
+ * Result of simulating a batch of settles.
+ */
+interface SettlePremiumBatchResult {
+  /** Per-target outcomes, in input order */
+  results: SettlePremiumBatchTargetResult[];
+  /** Targets whose settle succeeds (include these in the sequence) */
+  settleable: SettleSequenceTarget[];
+  /** Number of targets that cannot be settled */
+  unsettleableCount: number;
+  /** Total premium the caller receives from the settleable targets (token 0) */
+  premium0: bigint;
+  /** Total premium the caller receives from the settleable targets (token 1) */
+  premium1: bigint;
+  /** Block metadata */
+  _meta: BlockMeta;
+}
+/**
+ * Parameters for simulateSettlePremiumBatch.
+ */
+interface SimulateSettlePremiumBatchParams {
+  /** Public client */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Caller (settler) account address */
+  account: Address$1;
+  /** Position IDs from the caller's account (full held list) */
+  positionIdListFrom: bigint[];
+  /** Buyers to simulate settling */
+  targets: SettleSequenceTarget[];
+  /** Optional block number for simulation */
+  blockNumber?: bigint;
+}
+/**
+ * Simulate settling each target buyer's owed long premium, all at one block.
+ *
+ * Individual failures (insolvent buyer, stale list, …) are soft: the target
+ * lands in the unsettleable partition instead of failing the batch. Only
+ * unexpected errors reject.
+ *
+ * @param params - Simulation parameters
+ * @returns Partitioned targets with per-target premium and totals
+ */
+declare function simulateSettlePremiumBatch(params: SimulateSettlePremiumBatchParams): Promise<SettlePremiumBatchResult>;
+/**
+ * Result of simulating a full settle sequence.
+ */
+interface SettleSequenceSimulation {
+  /** Caller's net token 0 flow across the whole sequence */
+  delta0: bigint;
+  /** Caller's net token 1 flow across the whole sequence */
+  delta1: bigint;
+}
+/**
+ * Parameters for simulateSettleSequence.
+ */
+interface SimulateSettleSequenceParams extends SettleSequenceCallsParams {
+  /** Public client */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Caller (settler) account address */
+  account: Address$1;
+  /** Optional block number for simulation */
+  blockNumber?: bigint;
+}
+/**
+ * Simulate a full settle sequence (all settles + optional close) as the one
+ * multicall that `executeSettleSequence` submits, measuring the caller's
+ * total token flow and gas.
+ *
+ * @param params - Simulation parameters
+ * @returns Simulation result with the caller's net flow, or error
+ */
+declare function simulateSettleSequence(params: SimulateSettleSequenceParams): Promise<SimulationResult<SettleSequenceSimulation>>;
+
+//#endregion
+//#region src/panoptic/v2/simulations/simulateSettlePremiumFrom.d.ts
+/**
+ * Parameters for simulating settling another account's long premium.
+ */
+interface SimulateSettlePremiumFromParams {
+  /** Public client */
+  client: PublicClient;
+  /** PanopticPool address */
+  poolAddress: Address$1;
+  /** Caller (settler) account address */
+  account: Address$1;
+  /** Account whose long premium is being settled */
+  user: Address$1;
+  /** Position IDs from the caller's account (full held list) */
+  positionIdListFrom: bigint[];
+  /** The target user's full held position ID list (passed as both To and ToFinal) */
+  positionIdList: bigint[];
+  /** The target position to settle; reordered to the end of the list when provided */
+  tokenId?: bigint;
+  /** Optional block number for simulation */
+  blockNumber?: bigint;
+}
+/**
+ * Simulate settling another account's accumulated long premium via `dispatchFrom`
+ * (equal-length `positionIdListTo`/`positionIdListToFinal` selects the settle mode).
+ *
+ * The measured token flow is the CALLER's collateral delta — i.e. the premium
+ * the caller receives from the settlement (for chunks they sold).
+ *
+ * @param params - Simulation parameters
+ * @returns Simulation result with settled premium data or error
+ */
+declare function simulateSettlePremiumFrom(params: SimulateSettlePremiumFromParams): Promise<SimulationResult<SettlePremiumFromSimulation>>;
+
 //#endregion
 //#region src/panoptic/v2/simulations/simulateVault.d.ts
 /**
@@ -10827,56 +11320,6 @@ declare function simulateSwapExactOut(params: SimulateSwapExactOutParams): Promi
  */
 declare function simulateSwapExactIn(params: SimulateSwapExactInParams): Promise<SimulationResult<SwapSimulation>>;
 
-//#endregion
-//#region src/panoptic/v2/simulations/creditWrap.d.ts
-/**
- * Pre-encoded `dispatch()` arguments a credit wrap is applied to.
- *
- * Alias of {@link BatchDispatchArgs} — the two are the same concept.
- */
-type DispatchIntent = BatchDispatchArgs;
-/**
- * Which side of the swap is exact.
- *
- * - `exact-out`: the credit **sources** a known amount of its token, paying a
- *   swapped amount of the counter-token. Mint carries `swapAtMint=true`.
- * - `exact-in`: the credit **sells** a known amount of its token, receiving a
- *   swapped amount of the counter-token. Burn carries `swapAtMint=true`.
- */
-type CreditWrapDirection = 'exact-in' | 'exact-out';
-/**
- * Where the two credit legs sit relative to the user's own operations.
- *
- * - `straddle`: mint first, user ops, burn last. Required for `exact-out`, where
- *   the sourced token must be available while the user's ops run.
- * - `prepend`: both legs before the user's ops. Used by bootstrap recovery when
- *   the account can sell one collateral token but holds none of the token it needs.
- * - `append`: both legs after the user's ops, for flows where the token being
- *   sold does not exist until those operations run.
- */
-type CreditWrapPlacement = 'append' | 'prepend' | 'straddle';
-interface BuildCreditWrappedDispatchParams {
-  dispatch: DispatchIntent;
-  /** The temporary width=0 credit leg. */
-  creditTokenId: bigint;
-  /** Size of the mint leg. The burn leg always passes `0n` (= burn all). */
-  creditPositionSize: bigint;
-  tickLimitLow: bigint;
-  tickLimitHigh: bigint;
-  direction: CreditWrapDirection;
-  placement: CreditWrapPlacement;
-}
-/**
- * Wrap a dispatch with a temporary credit leg that is opened and closed in the
- * same transaction, netting to a swap.
- *
- * `swapAtMint` is not a calldata flag — it is the ORDER of the tick-limit pair:
- * descending `[high, low]` turns the swap on, ascending `[low, high]` leaves it
- * off. Exactly one of the two legs carries it, and which one is what makes the
- * swap exact-in vs exact-out.
- */
-declare function buildCreditWrappedDispatch(params: BuildCreditWrappedDispatchParams): DispatchIntent;
-
 //#endregion
 //#region src/panoptic/v2/simulations/oneTokenFlow.d.ts
 /**
@@ -14916,6 +15359,11 @@ declare function useAccountGreeks(poolAddress: Address$1, account?: Address$1, o
 declare function useMarginBuffer(poolAddress: Address$1, tokenIds: bigint[], queryAddress: Address$1, account?: Address$1, options?: QueryOptions): QueryObserverResult<TData, TError>;
 declare function useIsLiquidatable(poolAddress: Address$1, tokenIds: bigint[], queryAddress: Address$1, account?: Address$1, options?: QueryOptions): QueryObserverResult<TData, TError>;
 declare function useAccountPremia(poolAddress: Address$1, tokenIds: bigint[], account?: Address$1, options?: QueryOptions): QueryObserverResult<TData, TError>;
+/**
+ * Unsettled short premium the account would forfeit by closing `tokenIds` now
+ * (owed-including-pending minus available-to-collect).
+ */
+declare function useForfeitablePremium(poolAddress: Address$1, tokenIds: bigint[], account?: Address$1, options?: QueryOptions): QueryObserverResult<TData, TError>;
 declare function usePositionsWithPremia(poolAddress: Address$1, tokenIds: bigint[], account?: Address$1, options?: QueryOptions): QueryObserverResult<TData, TError>;
 declare function usePreviewDeposit(poolAddress: Address$1, tokenIndex: 0 | 1, amount: bigint, options?: QueryOptions): QueryObserverResult<TData, TError>;
 declare function usePreviewWithdraw(poolAddress: Address$1, tokenIndex: 0 | 1, amount: bigint, options?: QueryOptions): QueryObserverResult<TData, TError>;
@@ -15175,6 +15623,14 @@ declare function useClosePosition(poolAddress: Address$1): any;
 declare function useRollPosition(poolAddress: Address$1): any;
 declare function useLiquidate(poolAddress: Address$1): any;
 declare function useForceExercise(poolAddress: Address$1): any;
+/**
+ * Execute a settle sequence (settle N buyers, optionally close own position)
+ * as one multicall. The mutation resolves at submission with the TxResult so
+ * callers can track confirmation via `result.wait()` or event polling;
+ * invalidation therefore fires at submit time.
+ */
+declare function useExecuteSettleSequence(poolAddress: Address$1): any;
+declare function useSettlePremiumFrom(poolAddress: Address$1): any;
 declare function useSettleAccumulatedPremia(poolAddress: Address$1): any;
 declare function usePokeOracle(poolAddress: Address$1): any;
 declare function useDispatch(poolAddress: Address$1): any;
@@ -15198,6 +15654,20 @@ declare function useSimulateDeposit(params?: OmitClient<SimulateDepositParams>):
 declare function useSimulateWithdraw(params?: OmitClient<SimulateWithdrawParams>): QueryObserverResult<TData, TError>;
 declare function useSimulateLiquidate(poolAddress: Address$1, params?: OmitClientAndPool<SimulateLiquidateParams>): QueryObserverResult<TData, TError>;
 declare function useSimulateForceExercise(poolAddress: Address$1, params?: OmitClientAndPool<SimulateForceExerciseParams>): QueryObserverResult<TData, TError>;
+/**
+ * Simulate settling several buyers' owed premium at one block, partitioning
+ * them into settleable vs unsettleable and summing the caller's unlocked
+ * premium. Refetches on every call (staleTime 0) so the partition reflects
+ * current chain state.
+ */
+declare function useSimulateSettlePremiumBatch(poolAddress: Address$1, params?: OmitClientAndPool<SimulateSettlePremiumBatchParams>): QueryObserverResult<TData, TError>;
+/**
+ * Simulate a full settle sequence (per-buyer settles + optional close/dispatch)
+ * as the single multicall that will be submitted, returning the caller's net
+ * token flow and gas. Refetches on every call (staleTime 0).
+ */
+declare function useSimulateSettleSequence(poolAddress: Address$1, params?: OmitClientAndPool<SimulateSettleSequenceParams>): QueryObserverResult<TData, TError>;
+declare function useSimulateSettlePremiumFrom(poolAddress: Address$1, params?: OmitClientAndPool<SimulateSettlePremiumFromParams>): QueryObserverResult<TData, TError>;
 declare function useSimulateSettle(poolAddress: Address$1, params?: OmitClientAndPool<SimulateSettleParams>): QueryObserverResult<TData, TError>;
 declare function useSimulateBatchDispatch(poolAddress: Address$1, params?: OmitClientAndPool<SimulateBatchDispatchParams>): QueryObserverResult<TData, TError>;
 declare function useSimulateDispatch(poolAddress: Address$1, params?: OmitClientAndPool<SimulateDispatchParams>): QueryObserverResult<TData, TError>;
@@ -15860,6 +16330,12 @@ declare const queryKeys: {
    * Key for positions with premia.
    */
   readonly positionsWithPremia: (chainId: bigint, poolAddress: Address, account: Address) => readonly ["panoptic-v2", "positionsWithPremia", string, Address, Address];
+  /**
+   * Key prefix for forfeitable premium. Used both as the query key prefix (the
+   * hook appends the client scope and tokenIds) and for prefix invalidation
+   * after settle / force-exercise mutations.
+   */
+  readonly forfeitablePremium: (chainId: bigint, poolAddress: Address, account: Address) => readonly ["panoptic-v2", "forfeitablePremium", string, Address, Address];
   /**
    * Key for collateral data.
    */
@@ -15901,5 +16377,5 @@ declare const queryKeys: {
 };
 
 //#endregion
-export { AccountBuyingPower, AccountCollateral, AccountGreeksCurveResult, AccountGreeksResult, AccountInsolventError, AccountLiquidatedEvent, AccountPremia, AccountSummaryBasic, AccountSummaryRisk, AddPendingPositionParams, AddTrackedChunksParams, AlreadyInitializedError, ApprovalStatus, ApproveParams, ApprovePoolParams, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BaseEvent, BatchDiagnostic, BatchDiagnosticCode, BatchDispatchArgs, BatchOp, BatchOpBurn, BatchOpKind, BatchOpMint, BatchValidationError, BelowMinimumRedemptionError, BlockMeta, BorrowParams, BuildBatchDispatchArgsParams, BuildBatchDispatchArgsResult, BuildCreditWrappedDispatchParams, BuildTemporaryLoanRecoveryDispatchParams, BuildTokenShortfallRecoveryDispatchParams, CalculateAccountGreeksPureParams, CancelParams, CastingError, ChainDeployment, CheckApprovalParams, CheckCollateralAcrossTicksParams, ChunkData, ChunkHasZeroLiquidityError, ChunkInput, ChunkKey, ChunkLimitError, ChunkLiquidityResult, ChunkMetadata, ChunkSpread, ChunkStats, ClosePositionParams, ClosePositionSimulation, ClosedPosition, CollateralAcrossTicks, CollateralBreakdown, CollateralDataPoint, CollateralEstimate, CollateralSharePriceData, CollateralStrategyKind, CollateralTracker, ConfirmPendingPositionParams, CreateEventPollerParams, CreateEventSubscriptionParams, CreateFlowNeutralTokenIdParams, CreditSwapCall, CreditSwapCallParams, CreditWrapDirection, CreditWrapPlacement, CrossPoolError, CurrentRates, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DataWithMeta, DecodedLeg, DecodedOraclePack, DecodedTokenId, DeltaHedgeResult, DeployNewPoolParams, DepositEvent, DepositParams, DepositSimulation, DepositTooLargeError, DeriveStrategy, DeriveUniqueTokenIdParams, DeriveUniqueTokenIdResult, DetectReorgParams, DispatchCall, DispatchCalldata, DispatchIntent, DispatchParams, DispatchSimulation, DuplicateTokenIdError, ERC4626PreviewParams, ERC4626PreviewResult, EffectiveLiquidityAboveThresholdError, EncodeLegParams, EnforcedTickLimits, EnsureSfpmV3PoolInitializedParams, EnsureSfpmV3PoolInitializedResult, EstimateBlockNumbersParams, EstimateCollateralBreakdownParams, EstimateCollateralRequiredParams, EventPoller, EventReconstructionParams, EventReconstructionResult, EventSubscription, EventSubscriptionHandle, ExceedsMaximumRedemptionError, ExecuteBatchDispatchParams, FailPendingPositionParams, FetchPoolIdParams, FetchPoolIdResult, FetchSfpmV3PoolIdParams, FlowNeutralTokenId, ForceExerciseParams, ForceExerciseSimulation, ForcedExercisedEvent, GetAccountBuyingPowerParams, GetAccountCollateralParams, GetAccountGreeksParams, GetAccountPremiaParams, GetAccountSummaryBasicParams, GetAccountSummaryRiskParams, GetBlockMetaParams, GetChunkLiquiditiesParams, GetChunkLiquiditiesResult, GetChunkSpreadsParams, GetCollateralDataParams, GetCurrentRatesParams, GetDeltaHedgeParamsInput, GetEnforcedTickLimitsParams, GetFactoryConstructMetadataParams, GetFactoryOwnerOfParams, GetFactoryTokenURIParams, GetGuardianUnlockStateParams, GetInterestStateParams, GetItmAmountsParams, GetLiquidationPricesParams, GetMarginBufferParams, GetMaxPositionSizeParams, GetMaxRedeemParams, GetMaxWithdrawableParams, GetNativeTokenPriceParams, GetNetLiquidationValueParams, GetNetLiquidationValuesParams, GetOpenPositionIdsParams, GetOpenPositionPreviewParams, GetOracleRiskParametersParams, GetOracleStateParams, GetPanopticPoolAddressParams, GetPanopticPoolFromPoolIdParams, GetPendingPositionsParams, GetPoolLiquiditiesParams, GetPoolMetadataParams, GetPoolParams, GetPortfolioValueParams, GetPositionChunkDataParams, GetPositionChunkDataResult, GetPositionEnrichmentDataParams, GetPositionEnrichmentDataResult, GetPositionGreeksParams, GetPositionParams, GetPositionsParams, GetPositionsWithPremiaParams, GetPriceHistoryParams, GetRealizedPnLParams, GetRequiredCreditForITMParams, GetRiskParametersParams, GetSafeModeParams, GetStreamiaHistoryParams, GetSyncStatusParams, GetTrackedChunksParams, GetTrackedPositionIdsParams, GetTradeHistoryParams, GetUniswapFeeHistoryParams, GetUniswapV3LpPositionStateParams, GetUniswapV3PoolFromIdParams, GetUniswapV3PoolInfoParams, GetUniswapV3PoolLiquiditiesParams, GetUniswapV4LpPositionStateParams, GetUniswapV4PoolBasicStateParams, GetUniswapV4PoolInfoParams, GetUniswapV4PoolKeyFromIdParams, GetUniswapV4PoolLiquiditiesParams, GetUtilizationParams, GuardianUnlockState, InputListFailError, InsufficientCreditLiquidityError, InterestState, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, IrmCurrent, IrmMarketStateInputs, IrmPoint, IsLiquidatableParams, ItmAmounts, LEG_BITS, LEG_LIMITS, LEG_MASKS, LegChunkData, LegConfig, LegGreeksParams, LegUpdate, LengthMismatchError, LiquidateParams, LiquidateSimulation, LiquidationCheck, LiquidationPrices, LiquidityChunkKey, LiquidityChunkSpread, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MarginBuffer, MaxPositionSize, MaxRetriesExceededError, MinePoolAddressParams, MinePoolAddressResult, MintBufferRatio, MintParams, MissingPositionIdsError, MulticallContract, MulticallReadParams, MutationEffectParams, MutationType, NetLiquidationValue, NetLiquidationValues, NetLiquidityZeroError, NetworkMismatchError, NeutralLeg, NoLegsExercisableError, NonceManager, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OneTokenFlowQuote, OneTokenFlowQuoteParams, OneTokenFlowResult, OneTokenFlowUnavailableReason, OpenPositionParams, OpenPositionPreview, OpenPositionSimulation, OptimizeTokenIdRiskPartnersParams, OptionBurntEvent, OptionMintedEvent, OracleEmaPeriods, OracleRateLimitedError, OracleRiskParameters, OracleRiskParametersState, OracleSafeModeCause, OracleSafeModeDiagnosis, OracleState, OracleTiming, PanopticContextValue, PanopticError, PanopticEvent, PanopticEventType, PanopticHelperNotDeployedError, PanopticNFTMetadata, PanopticProvider, PanopticProviderProps, PanopticValidationError, ParsedError, PendingPosition, PokeOracleParams, Pool, PoolFormatterConfig, PoolFormatters, PoolHealthStatus, PoolKey, PoolLiquidities, PoolMetadata, PoolNotInitializedError, PoolVersionConfig, PortfolioValue, Position, PositionChunkData, PositionCountNotZeroError, PositionEnrichmentResult, PositionGreeks, PositionGreeksInput, PositionGreeksResult, PositionInput, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionStorageParams, PositionTooLargeError, PositionWithPremia, PositionsWithPremiaResult, PremiumSettledEvent, PreviewBorrowParams, PreviewBorrowResult, PreviewWrapParams, PriceBoundFailError, PriceHistoryResult, PriceHistoryTimeRange, PriceImpactTooLargeError, PriceSnapshot, ProviderLagError, QueryOptions, QuoteSfpmSwapParams, QuoteV3ExactInParams, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, RealizedPnL, ReconnectConfig, RecoverSnapshotFromTxParams, RecoverSnapshotParams, RedeemParams, ReentrancyError, RemoveTrackedChunksParams, ReorgDetection, RepayParams, RequiredCreditForITM, ResolveBlockNumbersParams, ResolvePanopticPoolFromPoolIdParams, ResolvePanopticPoolFromPoolIdResult, ResolveUniswapV4PoolKeyParams, RiskEngine, RiskParameters, RollPositionParams, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, SFPMSimulationResult, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeMode, SafeModeError, SafeModeState, SaveCheckpointParams, SaveClosedPositionParams, ScanChunksParams, ScanChunksResult, ScannedChunk, SettleParams, SettleSimulation, SettledEvent, SfpmSwapCalldata, SfpmSwapKind, SfpmSwapPlan, SfpmSwapPlanParams, SfpmSwapQuote, SimulateBatchDispatchParams, SimulateBatchDispatchResult, SimulateClosePositionParams, SimulateDeployNewPoolParams, SimulateDepositParams, SimulateDispatchParams, SimulateForceExerciseParams, SimulateLiquidateParams, SimulateOpenPositionParams, SimulateSFPMParams, SimulateSettleParams, SimulateSwapExactInParams, SimulateSwapExactOutParams, SimulateWithTokenFlowParams, SimulateWithTokenFlowResult, SimulateWithdrawParams, SimulationResult, SmartRepayParams, SnapshotRecoveryResult, SpeedUpParams, StaleDataError, StaleOracleError, StorageAdapter, StrategyAllocation, StrategyGroup, StreamiaHistoryResult, StreamiaLeg, StreamiaSnapshot, SupplyParams, SwapExactInParams, SwapExactOutParams, SwapSimulation, SwapTokenMismatchError, SyncCheckpoint, SyncEvent, SyncOptions, SyncPositionsParams, SyncPositionsResult, SyncProgressEvent, SyncResult, SyncState, SyncStatus, SyncStatusResult, SyncTimeoutError, TOKEN_ID_BITS, TemporaryLoanRecoveryQuote, TemporaryLoanRecoveryQuoteParams, TemporaryLoanRecoveryResult, TemporaryLoanRecoveryUnavailableReason, TickAndSpreadLimits, TickLimitsResult, Timescale, TokenCollateral, TokenFlow, TokenIdBuilder, TokenIdHasZeroLegsError, TokenIdLeg, TokenInterestState, TokenShortfallRecoveryQuote, TokenShortfallRecoveryQuoteParams, TokenShortfallRecoveryResult, TokenShortfallRecoveryUnavailableReason, TooManyLegsOpenError, TransferFailedError, TxBroadcaster, TxOverrides, TxReceipt, TxResult, TxResultWithReceipt, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UniswapFeeHistoryResult, UniswapFeeSnapshot, UniswapLpPositionState, UniswapV3Liquidities, UniswapV3LpPositionState, UniswapV3PoolInfo, UniswapV3PoolToken, UniswapV4PoolBasicState, UniswapV4PoolInfo, UniswapV4PoolKey, UnsupplyParams, UnwrapWethParams, UnwrapXstockParams, Utilization, V3ExactInQuote, V3PoolConfig, V4PoolConfig, ValidateBatchParams, WAD, WatchEventsParams, WithdrawEvent, WithdrawParams, WithdrawSimulation, WithdrawWithPositionsParams, WrapEthParams, WrapXstockParams, WriteConfig, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountBuyingPower, AccountCollateral, AccountGreeksCurveResult, AccountGreeksResult, AccountInsolventError, AccountLiquidatedEvent, AccountPremia, AccountSummaryBasic, AccountSummaryRisk, AddPendingPositionParams, AddTrackedChunksParams, AlreadyInitializedError, ApprovalStatus, ApproveParams, ApprovePoolParams, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BaseEvent, BatchDiagnostic, BatchDiagnosticCode, BatchDispatchArgs, BatchOp, BatchOpBurn, BatchOpKind, BatchOpMint, BatchValidationError, BelowMinimumRedemptionError, BlockMeta, BorrowParams, BuildBatchDispatchArgsParams, BuildBatchDispatchArgsResult, BuildCreditWrappedDispatchParams, BuildTemporaryLoanRecoveryDispatchParams, BuildTokenShortfallRecoveryDispatchParams, CalculateAccountGreeksPureParams, CancelParams, CastingError, ChainDeployment, CheckApprovalParams, CheckCollateralAcrossTicksParams, ChunkData, ChunkHasZeroLiquidityError, ChunkInput, ChunkKey, ChunkLimitError, ChunkLiquidityResult, ChunkMetadata, ChunkSpread, ChunkStats, ClosePositionParams, ClosePositionSimulation, ClosedPosition, CollateralAcrossTicks, CollateralBreakdown, CollateralDataPoint, CollateralEstimate, CollateralSharePriceData, CollateralStrategyKind, CollateralTracker, ConfirmPendingPositionParams, CreateEventPollerParams, CreateEventSubscriptionParams, CreateFlowNeutralTokenIdParams, CreditSwapCall, CreditSwapCallParams, CreditWrapDirection, CreditWrapPlacement, CrossPoolError, CurrentRates, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DataWithMeta, DecodedLeg, DecodedOraclePack, DecodedTokenId, DeltaHedgeResult, DeployNewPoolParams, DepositEvent, DepositParams, DepositSimulation, DepositTooLargeError, DeriveStrategy, DeriveUniqueTokenIdParams, DeriveUniqueTokenIdResult, DetectReorgParams, DispatchCall, DispatchCalldata, DispatchIntent, DispatchParams, DispatchSimulation, DuplicateTokenIdError, ERC4626PreviewParams, ERC4626PreviewResult, EffectiveLiquidityAboveThresholdError, EncodeLegParams, EnforcedTickLimits, EnsureSfpmV3PoolInitializedParams, EnsureSfpmV3PoolInitializedResult, EstimateBlockNumbersParams, EstimateCollateralBreakdownParams, EstimateCollateralRequiredParams, EventPoller, EventReconstructionParams, EventReconstructionResult, EventSubscription, EventSubscriptionHandle, ExceedsMaximumRedemptionError, ExecuteBatchDispatchParams, ExecuteSettleSequenceParams, FailPendingPositionParams, FetchPoolIdParams, FetchPoolIdResult, FetchSfpmV3PoolIdParams, FlowNeutralTokenId, ForceExerciseParams, ForceExerciseSimulation, ForcedExercisedEvent, ForfeitablePremium, GenerateOverlappingTokenIdsParams, GenerateOverlappingTokenIdsResult, GetAccountBuyingPowerParams, GetAccountCollateralParams, GetAccountGreeksParams, GetAccountPremiaParams, GetAccountSummaryBasicParams, GetAccountSummaryRiskParams, GetBlockMetaParams, GetChunkLiquiditiesParams, GetChunkLiquiditiesResult, GetChunkSpreadsParams, GetCollateralDataParams, GetCurrentRatesParams, GetDeltaHedgeParamsInput, GetEnforcedTickLimitsParams, GetFactoryConstructMetadataParams, GetFactoryOwnerOfParams, GetFactoryTokenURIParams, GetForfeitablePremiumParams, GetGuardianUnlockStateParams, GetInterestStateParams, GetItmAmountsParams, GetLiquidationPricesParams, GetMarginBufferParams, GetMaxPositionSizeParams, GetMaxRedeemParams, GetMaxWithdrawableParams, GetNativeTokenPriceParams, GetNetLiquidationValueParams, GetNetLiquidationValuesParams, GetOpenPositionIdsParams, GetOpenPositionPreviewParams, GetOracleRiskParametersParams, GetOracleStateParams, GetPanopticPoolAddressParams, GetPanopticPoolFromPoolIdParams, GetPendingPositionsParams, GetPoolLiquiditiesParams, GetPoolMetadataParams, GetPoolParams, GetPortfolioValueParams, GetPositionChunkDataParams, GetPositionChunkDataResult, GetPositionEnrichmentDataParams, GetPositionEnrichmentDataResult, GetPositionGreeksParams, GetPositionParams, GetPositionsParams, GetPositionsWithPremiaParams, GetPriceHistoryParams, GetRealizedPnLParams, GetRequiredCreditForITMParams, GetRiskParametersParams, GetSafeModeParams, GetStreamiaHistoryParams, GetSyncStatusParams, GetTrackedChunksParams, GetTrackedPositionIdsParams, GetTradeHistoryParams, GetUniswapFeeHistoryParams, GetUniswapV3LpPositionStateParams, GetUniswapV3PoolFromIdParams, GetUniswapV3PoolInfoParams, GetUniswapV3PoolLiquiditiesParams, GetUniswapV4LpPositionStateParams, GetUniswapV4PoolBasicStateParams, GetUniswapV4PoolInfoParams, GetUniswapV4PoolKeyFromIdParams, GetUniswapV4PoolLiquiditiesParams, GetUtilizationParams, GuardianUnlockState, InputListFailError, InsufficientCreditLiquidityError, InterestState, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, IrmCurrent, IrmMarketStateInputs, IrmPoint, IsLiquidatableParams, ItmAmounts, LEG_BITS, LEG_LIMITS, LEG_MASKS, LegChunkData, LegConfig, LegGreeksParams, LegUpdate, LengthMismatchError, LiquidateParams, LiquidateSimulation, LiquidationCheck, LiquidationPrices, LiquidityChunkKey, LiquidityChunkSpread, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MarginBuffer, MaxPositionSize, MaxRetriesExceededError, MinePoolAddressParams, MinePoolAddressResult, MintBufferRatio, MintParams, MissingPositionIdsError, MulticallContract, MulticallReadParams, MutationEffectParams, MutationType, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidationValue, NetLiquidationValues, NetLiquidityZeroError, NetworkMismatchError, NeutralLeg, NoLegsExercisableError, NonceManager, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OneTokenFlowQuote, OneTokenFlowQuoteParams, OneTokenFlowResult, OneTokenFlowUnavailableReason, OpenPositionParams, OpenPositionPreview, OpenPositionSimulation, OptimizeTokenIdRiskPartnersParams, OptionBurntEvent, OptionMintedEvent, OracleEmaPeriods, OracleRateLimitedError, OracleRiskParameters, OracleRiskParametersState, OracleSafeModeCause, OracleSafeModeDiagnosis, OracleState, OracleTiming, OverlappingOptionLegConfig, OverlappingOptionType, PanopticContextValue, PanopticError, PanopticEvent, PanopticEventType, PanopticHelperNotDeployedError, PanopticNFTMetadata, PanopticProvider, PanopticProviderProps, PanopticValidationError, ParsedError, PendingPosition, PokeOracleParams, Pool, PoolFormatterConfig, PoolFormatters, PoolHealthStatus, PoolKey, PoolLiquidities, PoolMetadata, PoolNotInitializedError, PoolVersionConfig, PortfolioValue, Position, PositionChunkData, PositionCountNotZeroError, PositionEnrichmentResult, PositionGreeks, PositionGreeksInput, PositionGreeksResult, PositionInput, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionStorageParams, PositionTooLargeError, PositionWithPremia, PositionsWithPremiaResult, PremiumSettledEvent, PreviewBorrowParams, PreviewBorrowResult, PreviewWrapParams, PriceBoundFailError, PriceHistoryResult, PriceHistoryTimeRange, PriceImpactTooLargeError, PriceSnapshot, ProviderLagError, QueryOptions, QuoteSfpmSwapParams, QuoteV3ExactInParams, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, RealizedPnL, ReconnectConfig, RecoverSnapshotFromTxParams, RecoverSnapshotParams, RedeemParams, ReentrancyError, RemoveTrackedChunksParams, ReorgDetection, RepayParams, RequiredCreditForITM, ResolveBlockNumbersParams, ResolvePanopticPoolFromPoolIdParams, ResolvePanopticPoolFromPoolIdResult, ResolveUniswapV4PoolKeyParams, RiskEngine, RiskParameters, RollPositionParams, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, SFPMSimulationResult, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, SafeMode, SafeModeError, SafeModeState, SaveCheckpointParams, SaveClosedPositionParams, ScanChunksParams, ScanChunksResult, ScannedChunk, SettleParams, SettlePremiumBatchResult, SettlePremiumBatchTargetResult, SettlePremiumFromParams, SettlePremiumFromSimulation, SettleSequenceCallsParams, SettleSequenceClose, SettleSequenceSimulation, SettleSequenceTarget, SettleSimulation, SettledEvent, SfpmSwapCalldata, SfpmSwapKind, SfpmSwapPlan, SfpmSwapPlanParams, SfpmSwapQuote, SimulateBatchDispatchParams, SimulateBatchDispatchResult, SimulateClosePositionParams, SimulateDeployNewPoolParams, SimulateDepositParams, SimulateDispatchParams, SimulateForceExerciseParams, SimulateLiquidateParams, SimulateOpenPositionParams, SimulateSFPMParams, SimulateSettleParams, SimulateSettlePremiumBatchParams, SimulateSettlePremiumFromParams, SimulateSettleSequenceParams, SimulateSwapExactInParams, SimulateSwapExactOutParams, SimulateWithTokenFlowParams, SimulateWithTokenFlowResult, SimulateWithdrawParams, SimulationResult, SmartRepayParams, SnapshotRecoveryResult, SpeedUpParams, SplitTokenIdByTimescaleResult, StaleDataError, StaleOracleError, StorageAdapter, StrategyAllocation, StrategyGroup, StreamiaHistoryResult, StreamiaLeg, StreamiaSnapshot, SupplyParams, SwapExactInParams, SwapExactOutParams, SwapSimulation, SwapTokenMismatchError, SyncCheckpoint, SyncEvent, SyncOptions, SyncPositionsParams, SyncPositionsResult, SyncProgressEvent, SyncResult, SyncState, SyncStatus, SyncStatusResult, SyncTimeoutError, TOKEN_ID_BITS, TemporaryLoanRecoveryQuote, TemporaryLoanRecoveryQuoteParams, TemporaryLoanRecoveryResult, TemporaryLoanRecoveryUnavailableReason, TickAndSpreadLimits, TickLimitsResult, Timescale, TokenCollateral, TokenFlow, TokenIdBuilder, TokenIdHasZeroLegsError, TokenIdLeg, TokenInterestState, TokenShortfallRecoveryQuote, TokenShortfallRecoveryQuoteParams, TokenShortfallRecoveryResult, TokenShortfallRecoveryUnavailableReason, TooManyLegsOpenError, TransferFailedError, TxBroadcaster, TxOverrides, TxReceipt, TxResult, TxResultWithReceipt, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UniswapFeeHistoryResult, UniswapFeeSnapshot, UniswapLpPositionState, UniswapV3Liquidities, UniswapV3LpPositionState, UniswapV3PoolInfo, UniswapV3PoolToken, UniswapV4PoolBasicState, UniswapV4PoolInfo, UniswapV4PoolKey, UnsupplyParams, UnwrapWethParams, UnwrapXstockParams, Utilization, V3ExactInQuote, V3PoolConfig, V4PoolConfig, ValidateBatchParams, WAD, WatchEventsParams, WithdrawEvent, WithdrawParams, WithdrawSimulation, WithdrawWithPositionsParams, WrapEthParams, WrapXstockParams, WriteConfig, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculateResyncBlock, calculateSpreadWad, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralData, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCowSupportedChain, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, liquidate, liquidateAndWait, loadCheckpoint, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, mutationEffects, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticPoolV2Abi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, previewBorrow, previewDeposit, previewMint, previewRedeem, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, queryKeys, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteV3ExactIn, ratePerSecWadToAprPct, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scanChunks, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, useAccountCollateral, useAccountGreeks, useAccountPremia, useAccountSummaryBasic, useAccountSummaryRisk, useAddPendingPosition, useApprove, useApproveErc20ForCow, useApproveErc20ForPermit2, useApprovePool, useApproveRouterViaPermit2, useBatchDispatch as useBatchDispatchHook, useBorrow as useBorrowHook, useCancelCowOrder, useCheckCowApproval, useCheckRouterApproval, useChunkSpreads, useClearTrackedPositions, useClosePosition as useClosePositionHook, useClosedPositions, useCollateralBreakdown, useCollateralData, useConfirmPendingPosition, useCowOrderStatus, useCurrentRates, useDeployNewPool as useDeployNewPoolHook, useDeposit as useDepositHook, useDispatch as useDispatchHook, useEstimateCollateralRequired, useEventPoller, useEventSubscription, useExecuteSettleSequence, useFactoryConstructMetadata, useFactoryOwnerOf, useFactoryTokenURI, useFailPendingPosition, useFlowNeutralTokenId, useForceExercise as useForceExerciseHook, useForfeitablePremium, useGuardianUnlockState, useInterestState, useIsLiquidatable, useLiquidate as useLiquidateHook, useLiquidationPrices, useMarginBuffer, useMaxPositionSize, useMaxRedeem, useMaxWithdrawable, useMinePoolAddress as useMinePoolAddressHook, useMintShares, useNativeTokenPrice, useNetLiquidationValue, useNetLiquidationValues, useOpenPosition as useOpenPositionHook, useOpenPositionPreview, useOptimizeRiskPartners, useOracleState, usePanopticContext, usePanopticPoolAddress, usePokeOracle as usePokeOracleHook, usePool, usePoolLiquidities, usePosition, usePositionGreeks, usePositions, usePositionsWithPremia, usePreviewBorrow, usePreviewDeposit, usePreviewMint, usePreviewRedeem, usePreviewWithdraw, usePriceHistory, useQuoteCowSwap, useQuoteSwapExactInViaRouter, useQuoteSwapExactOutViaRouter, useRealizedPnL, useRedeem as useRedeemHook, useRepay as useRepayHook, useResolveUniswapV4PoolKey, useRiskParameters, useRollPosition as useRollPositionHook, useSafeMode, useSettleAccumulatedPremia as useSettleAccumulatedPremiaHook, useSettlePremiumFrom as useSettlePremiumFromHook, useSimulateBatchDispatch, useSimulateClosePosition, useSimulateDeployNewPool, useSimulateDeposit, useSimulateDispatch, useSimulateForceExercise, useSimulateLiquidate, useSimulateOpenPosition, useSimulateSFPMBurn, useSimulateSFPMMint, useSimulateSettle, useSimulateSettlePremiumBatch, useSimulateSettlePremiumFrom, useSimulateSettleSequence, useSimulateSwapExactIn, useSimulateSwapExactOut, useSimulateWithdraw, useSmartRepay as useSmartRepayHook, useStreamiaHistory, useSubmitCowOrder, useSupply as useSupplyHook, useSwapExactIn, useSwapExactInViaRouter, useSwapExactOut, useSwapExactOutViaRouter, useSyncPositions, useSyncStatus, useTrackedPositionIds, useTradeHistory, useTxEventConfirmation, useUniswapFeeHistory, useUniswapV3PoolInfo, useUniswapV3PoolLiquidities, useUniswapV4PoolBasicState, useUniswapV4PoolInfo, useUniswapV4PoolLiquidities, useUnsupply as useUnsupplyHook, useUnwrapWeth, useUnwrapXstock, useUtilization, useValidateBuilderCode, useWatchEvents, useWithdraw as useWithdrawHook, useWithdrawWithPositions as useWithdrawWithPositionsHook, useWrapEth, useWrapXstock, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=react-public.d.ts.map