@panoptic-eng/sdk 1.0.38 → 1.0.39

package/dist/uniswap/index.d.ts

@@ -1,12 +1,113 @@
-import { PanopticError, PoolKey, SimulationResult, TxReceipt, TxResult } from "../index-Bo9tHtD7.js";
-import "../irm-D5plRhpB.js";
-import { QuoteV3ExactInParams, UNISWAP_V3_ADDRESSES$1 as UNISWAP_V3_ADDRESSES, UniswapV3Addresses, V3ExactInQuote, getUniswapV3Addresses$1 as getUniswapV3Addresses, quoteV3ExactIn$1 as quoteV3ExactIn } from "../quote-DeHNUR0Z.js";
-import { ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, CheckRouterApprovalParams, PERMIT2_ADDRESS$1 as PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, RouterApprovalStatus, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, UNISWAP_V4_ADDRESSES$1 as UNISWAP_V4_ADDRESSES, UniswapV4Addresses, getUniswapV4Addresses$1 as getUniswapV4Addresses } from "../types-Cad5m4Td.js";
-import { Address, Hex, PublicClient } from "viem";
+import { Address, Hash, Hex, PublicClient, WalletClient } from "viem";
 
-//#region src/uniswap/v3/router/encodeSwap.d.ts
-/** Universal Router command byte for a v3 exact-in swap. */
+//#region src/uniswap/lpGreeks.d.ts
+/**
+* Greeks for plain (non-Panoptic) Uniswap v3/v4 concentrated-liquidity LP
+* positions. Pure math over on-chain position fields (liquidity + tick range)
+* and the pool's current price — no RPC, no protocol dependency.
+*
+* Units follow the Panoptic v2 greeks convention (see
+* `packages/sdk/src/panoptic/v2/greeks/index.ts`) so a caller can present LP
+* and Panoptic greeks side by side:
+*   - `value`  → numeraire-token smallest units
+*   - `delta`  → asset-token smallest units (the asset held by the LP)
+*   - `gamma`  → numeraire-token smallest units (dollar-gamma `P²·d²V/dP²`;
+*                always ≤ 0 because an LP is short gamma)
+*
+* `assetIndex` selects which token is the "asset" (the volatile leg being
+* hedged): `0` → token0 is the asset / token1 the numeraire; `1` → the reverse.
+*
+* @module uniswap/lpGreeks
+*/
+/** Token amounts currently backing a concentrated-liquidity position. */
+/**
+ * Greeks for plain (non-Panoptic) Uniswap v3/v4 concentrated-liquidity LP
+ * positions. Pure math over on-chain position fields (liquidity + tick range)
+ * and the pool's current price — no RPC, no protocol dependency.
+ *
+ * Units follow the Panoptic v2 greeks convention (see
+ * `packages/sdk/src/panoptic/v2/greeks/index.ts`) so a caller can present LP
+ * and Panoptic greeks side by side:
+ *   - `value`  → numeraire-token smallest units
+ *   - `delta`  → asset-token smallest units (the asset held by the LP)
+ *   - `gamma`  → numeraire-token smallest units (dollar-gamma `P²·d²V/dP²`;
+ *                always ≤ 0 because an LP is short gamma)
+ *
+ * `assetIndex` selects which token is the "asset" (the volatile leg being
+ * hedged): `0` → token0 is the asset / token1 the numeraire; `1` → the reverse.
+ *
+ * @module uniswap/lpGreeks
+ */
+/** Token amounts currently backing a concentrated-liquidity position. */
+interface LpAmounts {
+  /** token0 amount in its smallest units. */
+  amount0: bigint;
+  /** token1 amount in its smallest units. */
+  amount1: bigint;
+}
+/** Greeks of a Uniswap LP position in one asset frame (see module docs for units). */
+interface LpGreeks {
+  /** Position value in numeraire-token smallest units. */
+  value: bigint;
+  /** Delta in asset-token smallest units (the asset amount the LP is long). */
+  delta: bigint;
+  /** Dollar-gamma in numeraire-token smallest units; ≤ 0 (LP is short gamma). */
+  gamma: bigint;
+}
+/** Inputs describing a single LP position + the pool's current price. */
+interface LpGreeksInput {
+  /** Position liquidity `L`. */
+  liquidity: bigint;
+  /** Lower tick of the range. */
+  tickLower: bigint;
+  /** Upper tick of the range. */
+  tickUpper: bigint;
+  /** Pool's current tick. */
+  currentTick: bigint;
+  /** Which token is the asset: `0` (token0) or `1` (token1). */
+  assetIndex: 0 | 1;
+}
+/**
+ * Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
+ * at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
+ * (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
+ * clamped into the range, so out-of-range positions collapse to a single token.
+ */
+declare function getAmountsForLiquidity(sqrtPriceX96: bigint, sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): LpAmounts;
+/**
+ * Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
+ * frame. See the module docs for the unit conventions.
+ *
+ * Closed forms (in-range, numeraire = token1 / asset = token0):
+ *   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
+ *   delta = amount0                            (= dV/dP)
+ *   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
+ * The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
+ * Gamma is zero when the price is outside the range (no curvature there).
+ */
+declare function getLpGreeks(input: LpGreeksInput): LpGreeks; //#endregion
+//#region src/uniswap/v3/addresses.d.ts
+interface UniswapV3Addresses {
+  /** Uniswap v3 QuoterV2 — `quoteExactInputSingle` (revert/staticcall-based). */
+  quoterV2: Address;
+  /** Uniswap v3 NonfungiblePositionManager — ERC721 LP position NFTs. */
+  nonfungiblePositionManager: Address;
+}
+/**
+ * Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
+ * after verifying against the canonical Uniswap v3 deployment listing.
+ */
+declare const UNISWAP_V3_ADDRESSES: Record<number, UniswapV3Addresses>;
+/**
+ * Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+ *
+ * @throws {UnsupportedChainError} when the chain is not listed and overrides do
+ *   not supply every required address.
+ */
+declare function getUniswapV3Addresses(chainId: number | bigint, overrides?: Partial<UniswapV3Addresses>): UniswapV3Addresses;
 
+//#endregion
+//#region src/uniswap/v3/router/encodeSwap.d.ts
 /** Universal Router command byte for a v3 exact-in swap. */
 declare const V3_SWAP_EXACT_IN = 0;
 /**
@@ -51,8 +152,508 @@ declare function buildV3SwapExecuteArgs(args: BuildV3SwapCalldataArgs): {
 declare function buildV3SwapExecuteCalldata(args: BuildV3SwapCalldataArgs): {
   data: Hex;
   value: bigint;
-}; //#endregion
+};
+
+//#endregion
+//#region src/uniswap/v3/router/quote.d.ts
+interface QuoteV3ExactInParams {
+  client: PublicClient;
+  chainId: bigint;
+  tokenIn: Address;
+  tokenOut: Address;
+  fee: bigint;
+  amountIn: bigint;
+  /** Slippage tolerance in bps, used to compute `amountOutMinimum`. */
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV3Addresses>;
+}
+interface V3ExactInQuote {
+  amountOut: bigint;
+  amountOutMinimum: bigint;
+  gasEstimate: bigint;
+}
+/**
+ * Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+ * pool does not exist / has no liquidity) so callers can skip that pool when
+ * ranking venues, rather than aborting the whole cycle.
+ */
+declare function quoteV3ExactIn(params: QuoteV3ExactInParams): Promise<V3ExactInQuote | null>;
+
+//#endregion
+//#region src/uniswap/v4/addresses.d.ts
+/**
+ * Uniswap v4 contract addresses required for a Universal Router spot swap.
+ */
+interface UniswapV4Addresses {
+  /** Universal Router (v4-capable build) — entrypoint for `execute(...)`. */
+  universalRouter: Address;
+  /** V4Quoter — `quoteExactInputSingle` (revert/staticcall-based). */
+  v4Quoter: Address;
+  /** Uniswap v4 PoolManager (singleton). */
+  poolManager: Address;
+  /** Uniswap v4 PositionManager (posm) — ERC721 LP position NFTs. */
+  positionManager: Address;
+  /** Canonical Permit2 (same address on every chain). */
+  permit2: Address;
+}
+/**
+ * Canonical Permit2, identical across all chains.
+ */
+declare const PERMIT2_ADDRESS: Address;
+/**
+ * Verified Uniswap v4 deployment addresses keyed by chainId.
+ *
+ * Sourced from the official Uniswap v4 deployments. Add a chain here only after
+ * verifying each address against the canonical Uniswap deployment listing —
+ * Universal Router in particular is NOT the same address across chains.
+ */
+declare const UNISWAP_V4_ADDRESSES: Record<number, UniswapV4Addresses>;
+/**
+ * Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
+ *
+ * @param chainId - Target chain ID.
+ * @param overrides - Partial override of any address (e.g. for fork tests).
+ * @returns Fully-resolved {@link UniswapV4Addresses}.
+ * @throws {UnsupportedChainError} when the chain is not listed and the
+ *   overrides do not supply every required address.
+ */
+declare function getUniswapV4Addresses(chainId: bigint, overrides?: Partial<UniswapV4Addresses>): UniswapV4Addresses;
+
+//#endregion
+//#region src/panoptic/v2/types/meta.d.ts
+/**
+ * Block metadata types for the Panoptic v2 SDK.
+ * @module v2/types/meta
+ */
+/**
+ * Block metadata attached to all RPC responses.
+ * Used for freshness checks and reorg detection.
+ */
+interface BlockMeta {
+  /** Block number when the data was fetched */
+  blockNumber: bigint;
+  /** Block timestamp in Unix seconds */
+  blockTimestamp: bigint;
+  /** Block hash for reorg detection */
+  blockHash: `0x${string}`;
+  /** Whether the data is considered stale */
+  isStale?: boolean;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/pool.d.ts
+/**
+ * Uniswap V4 pool key.
+ */
+interface PoolKey {
+  /** Token 0 address */
+  currency0: Address;
+  /** Token 1 address */
+  currency1: Address;
+  /** Fee tier */
+  fee: bigint;
+  /** Tick spacing */
+  tickSpacing: bigint;
+  /** Hook address (if any) */
+  hooks: Address;
+}
+
+//#endregion
+//#region src/panoptic/v2/types/events.d.ts
+/**
+ * Pool data returned by getPool().
+ */
+/**
+ * Supported Panoptic event types.
+ */
+type PanopticEventType = 'OptionMinted' | 'OptionBurnt' | 'AccountLiquidated' | 'ForcedExercised' | 'PremiumSettled' | 'Deposit' | 'Withdraw' | 'BorrowRateUpdated' | 'LiquidityChunkUpdated' | 'ProtocolLossRealized' | 'ModifyLiquidity' | 'Swap' | 'Donate';
+/**
+ * Base event data common to all events.
+ */
+interface BaseEvent {
+  /** Event type */
+  type: PanopticEventType;
+  /** Transaction hash */
+  transactionHash: Hash;
+  /** Block number */
+  blockNumber: bigint;
+  /** Block hash */
+  blockHash: Hash;
+  /** Log index within the block */
+  logIndex: bigint;
+}
+/**
+ * OptionMinted event data.
+ */
+interface OptionMintedEvent extends BaseEvent {
+  type: 'OptionMinted';
+  /** Recipient of the minted position */
+  recipient: Address;
+  /** TokenId of the minted position */
+  tokenId: bigint;
+  /** Position size */
+  positionSize: bigint;
+  /** Pool utilization for token 0 at mint */
+  poolUtilization0: bigint;
+  /** Pool utilization for token 1 at mint */
+  poolUtilization1: bigint;
+  /** Tick at mint */
+  tickAtMint: bigint;
+  /** Timestamp at mint (Unix seconds) */
+  timestampAtMint: bigint;
+  /** Block number at mint */
+  blockAtMint: bigint;
+  /** Whether a swap happened at mint */
+  swapAtMint: boolean;
+}
+/**
+ * OptionBurnt event data.
+ */
+interface OptionBurntEvent extends BaseEvent {
+  type: 'OptionBurnt';
+  /** Recipient (owner) of the burnt position */
+  recipient: Address;
+  /** TokenId of the burnt position */
+  tokenId: bigint;
+  /** Position size that was burnt */
+  positionSize: bigint;
+  /** Premia settled for each leg (token0 right, token1 left per leg) */
+  premiaByLeg: readonly [bigint, bigint, bigint, bigint];
+}
+/**
+ * AccountLiquidated event data.
+ */
+interface AccountLiquidatedEvent extends BaseEvent {
+  type: 'AccountLiquidated';
+  /** Address of the liquidator */
+  liquidator: Address;
+  /** Address of the liquidated account */
+  liquidatee: Address;
+  /** Bonus paid to liquidator for token 0 */
+  bonusAmount0: bigint;
+  /** Bonus paid to liquidator for token 1 */
+  bonusAmount1: bigint;
+}
+/**
+ * ForcedExercised event data.
+ */
+interface ForcedExercisedEvent extends BaseEvent {
+  type: 'ForcedExercised';
+  /** Address of the exerciser */
+  exercisor: Address;
+  /** Address of the position owner */
+  user: Address;
+  /** TokenId of the exercised position */
+  tokenId: bigint;
+  /** Exercise fee for token 0 (negative = cost to exerciser) */
+  exerciseFee0: bigint;
+  /** Exercise fee for token 1 (negative = cost to exerciser) */
+  exerciseFee1: bigint;
+}
+/**
+ * PremiumSettled event data.
+ */
+interface PremiumSettledEvent extends BaseEvent {
+  type: 'PremiumSettled';
+  /** Position owner */
+  user: Address;
+  /** TokenId */
+  tokenId: bigint;
+  /** Leg index that was settled */
+  legIndex: bigint;
+  /** Settled amount for token 0 */
+  settledAmount0: bigint;
+  /** Settled amount for token 1 */
+  settledAmount1: bigint;
+}
+/**
+ * Deposit event data (ERC4626).
+ */
+interface DepositEvent extends BaseEvent {
+  type: 'Deposit';
+  /** Sender address */
+  sender: Address;
+  /** Owner address */
+  owner: Address;
+  /** Assets deposited */
+  assets: bigint;
+  /** Shares minted */
+  shares: bigint;
+}
+/**
+ * Withdraw event data (ERC4626).
+ */
+interface WithdrawEvent extends BaseEvent {
+  type: 'Withdraw';
+  /** Sender address */
+  sender: Address;
+  /** Receiver address */
+  receiver: Address;
+  /** Owner address */
+  owner: Address;
+  /** Assets withdrawn */
+  assets: bigint;
+  /** Shares burned */
+  shares: bigint;
+}
+/**
+ * BorrowRateUpdated event data (RiskEngine).
+ */
+interface BorrowRateUpdatedEvent extends BaseEvent {
+  type: 'BorrowRateUpdated';
+  /** Collateral token address */
+  collateralToken: Address;
+  /** Average borrow rate */
+  avgBorrowRate: bigint;
+  /** Rate at target utilization */
+  rateAtTarget: bigint;
+}
+/**
+ * LiquidityChunkUpdated event data (SFPM).
+ */
+interface LiquidityChunkUpdatedEvent extends BaseEvent {
+  type: 'LiquidityChunkUpdated';
+  /** Pool ID (bytes32) */
+  poolId: Hash;
+  /** Owner address */
+  owner: Address;
+  /** Token type (0 or 1) */
+  tokenType: bigint;
+  /** Lower tick */
+  tickLower: number;
+  /** Upper tick */
+  tickUpper: number;
+  /** Liquidity delta (positive = added, negative = removed) */
+  liquidityDelta: bigint;
+}
+/**
+ * ProtocolLossRealized event data (CollateralTracker).
+ */
+interface ProtocolLossRealizedEvent extends BaseEvent {
+  type: 'ProtocolLossRealized';
+  /** Liquidated account */
+  liquidatee: Address;
+  /** Liquidator address */
+  liquidator: Address;
+  /** Protocol loss in assets */
+  protocolLossAssets: bigint;
+  /** Protocol loss in shares */
+  protocolLossShares: bigint;
+}
+/**
+ * ModifyLiquidity event data (v4 PoolManager).
+ */
+interface ModifyLiquidityEvent extends BaseEvent {
+  type: 'ModifyLiquidity';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Lower tick */
+  tickLower: number;
+  /** Upper tick */
+  tickUpper: number;
+  /** Liquidity delta */
+  liquidityDelta: bigint;
+  /** Salt */
+  salt: Hash;
+}
+/**
+ * Swap event data (v4 PoolManager).
+ */
+interface SwapEvent extends BaseEvent {
+  type: 'Swap';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Amount of token 0 */
+  amount0: bigint;
+  /** Amount of token 1 */
+  amount1: bigint;
+  /** Square root price X96 */
+  sqrtPriceX96: bigint;
+  /** Liquidity */
+  liquidity: bigint;
+  /** Tick */
+  tick: number;
+  /** Fee */
+  fee: number;
+}
+/**
+ * Donate event data (v4 PoolManager).
+ */
+interface DonateEvent extends BaseEvent {
+  type: 'Donate';
+  /** Pool ID (bytes32) */
+  id: Hash;
+  /** Sender address */
+  sender: Address;
+  /** Amount of token 0 */
+  amount0: bigint;
+  /** Amount of token 1 */
+  amount1: bigint;
+}
+/**
+ * Union of all Panoptic event types.
+ */
+type PanopticEvent = OptionMintedEvent | OptionBurntEvent | AccountLiquidatedEvent | ForcedExercisedEvent | PremiumSettledEvent | DepositEvent | WithdrawEvent | BorrowRateUpdatedEvent | LiquidityChunkUpdatedEvent | ProtocolLossRealizedEvent | ModifyLiquidityEvent | SwapEvent | DonateEvent;
+
+//#endregion
+//#region src/panoptic/v2/types/tx.d.ts
+/**
+ * Leg update data from events.
+ */
+/**
+ * Transaction result returned by write functions.
+ * Provides immediate access to hash and a wait function for confirmation.
+ */
+interface TxResult {
+  /** Transaction hash, available immediately */
+  hash: Hash;
+  /** Wait for transaction confirmation */
+  wait: (confirmations?: bigint) => Promise<TxReceipt>;
+}
+/**
+ * Transaction result with receipt already awaited.
+ * Returned by *AndWait convenience functions.
+ */
+
+/**
+ * Transaction receipt after confirmation.
+ */
+interface TxReceipt {
+  /** Transaction hash */
+  hash: Hash;
+  /** Block number */
+  blockNumber: bigint;
+  /** Block hash */
+  blockHash: Hash;
+  /** Gas used */
+  gasUsed: bigint;
+  /** Transaction status */
+  status: 'success' | 'reverted';
+  /** Parsed Panoptic events from the transaction */
+  events: PanopticEvent[];
+}
+/**
+ * Transaction broadcaster interface for private transaction support.
+ * Allows plugging in Flashbots or other MEV protection services.
+ */
+interface TxBroadcaster {
+  /**
+   * Broadcast a signed transaction.
+   * @param signedTx - The signed transaction bytes
+   * @returns The transaction hash
+   */
+  broadcast: (signedTx: `0x${string}`) => Promise<Hash>;
+}
+/**
+ * Gas and transaction overrides for write operations.
+ * Supports EIP-1559 gas parameters, explicit nonce, and custom broadcasters.
+ */
+interface TxOverrides {
+  /** EIP-1559 max fee per gas */
+  maxFeePerGas?: bigint;
+  /** EIP-1559 max priority fee per gas (tip) */
+  maxPriorityFeePerGas?: bigint;
+  /** Gas limit override */
+  gas?: bigint;
+  /** Explicit nonce (for concurrent tx submission) */
+  nonce?: bigint;
+  /** Custom broadcaster for MEV protection (Flashbots, private mempool) */
+  broadcaster?: TxBroadcaster;
+}
+
+//#endregion
+//#region src/panoptic/v2/errors/base.d.ts
+/**
+ * Nonce manager for concurrent transaction submission.
+ */
+/**
+ * Base error class for the Panoptic v2 SDK.
+ * @module v2/errors/base
+ */
+/**
+ * Base error class for all Panoptic SDK errors.
+ * All errors thrown by the SDK extend this class.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await openPosition(config, params)
+ * } catch (error) {
+ *   if (error instanceof PanopticError) {
+ *     console.log('Panoptic error:', error.name, error.message)
+ *     console.log('Original cause:', error.cause)
+ *   }
+ * }
+ * ```
+ */
+declare class PanopticError extends Error {
+  readonly cause?: Error | undefined;
+  readonly name: string;
+  /** The Solidity error name (e.g. 'PriceBoundFail', 'InputListFail'). Set by the parser. */
+  errorName?: string;
+  /**
+   * Creates a new PanopticError.
+   *
+   * @param message - Human-readable error message
+   * @param cause - Optional underlying error that caused this error
+   */
+  constructor(message: string, cause?: Error | undefined);
+}
+
+//#endregion
+//#region src/panoptic/v2/types/simulation.d.ts
+/**
+ * Token flow data from simulation.
+ * Measures collateral asset changes via getAssetsOf-dispatch-getAssetsOf pattern
+ * using PanopticPool.multicall.
+ */
+interface TokenFlow {
+  /** Token 0 collateral change (negative = user deposits, positive = user receives) */
+  delta0: bigint;
+  /** Token 1 collateral change (negative = user deposits, positive = user receives) */
+  delta1: bigint;
+  /** Collateral assets in token 0 before the call */
+  balanceBefore0: bigint;
+  /** Collateral assets in token 1 before the call */
+  balanceBefore1: bigint;
+  /** Collateral assets in token 0 after the call */
+  balanceAfter0: bigint;
+  /** Collateral assets in token 1 after the call */
+  balanceAfter1: bigint;
+  /** Pool tick before the operation */
+  tickBefore: bigint | null;
+  /** Pool tick after the operation */
+  tickAfter: bigint | null;
+}
+/**
+ * Simulation result discriminated union.
+ * Success case returns data, failure case returns error.
+ *
+ * Note: tokenFlow is optional because some simulations (deposit/withdraw)
+ * don't use the PanopticPool.multicall token flow measurement.
+ */
+type SimulationResult<T> = {
+  success: true;
+  data: T;
+  gasEstimate: bigint;
+  tokenFlow?: TokenFlow;
+  _meta: BlockMeta;
+} | {
+  success: false;
+  error: PanopticError;
+  _meta: BlockMeta;
+};
+
+//#endregion
 //#region src/uniswap/v4/router/encodeSwap.d.ts
+/**
+ * Open position simulation result data.
+ */
 /** Universal Router command byte for a v4 swap. */
 declare const V4_SWAP = 16;
 /** v4 action: exact-in single-hop swap. */
@@ -168,7 +769,9 @@ declare function buildV4ExactOutSwapExecuteArgs(args: BuildV4ExactOutSwapCalldat
 declare function buildV4ExactOutSwapExecuteCalldata(args: BuildV4ExactOutSwapCalldataArgs): {
   data: Hex;
   value: bigint;
-}; //#endregion
+};
+
+//#endregion
 //#region src/uniswap/v4/router/errors.d.ts
 /**
  * The chain has no configured Uniswap v4 addresses and none were supplied via
@@ -214,6 +817,207 @@ declare class QuoterUnavailableError extends PanopticError {
   constructor(chainId: bigint, cause?: Error);
 }
 
+//#endregion
+//#region src/uniswap/v4/router/types.d.ts
+/**
+ * Parameters for {@link swapExactInViaRouter}.
+ */
+interface SwapExactInViaRouterParams {
+  /** Public client for reads + receipts. */
+  client: PublicClient;
+  /** Wallet client for signing. */
+  walletClient: WalletClient;
+  /** Account address. */
+  account: Address;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID (selects per-chain Uniswap v4 addresses). */
+  chainId: bigint;
+  /** Token to sell. `address(0)` (zero address) for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of `tokenIn` to spend (must fit uint128). */
+  amountIn: bigint;
+  /** Slippage tolerance in bps (e.g. 500n = 5%). */
+  slippageBps: bigint;
+  /** Absolute deadline (unix seconds). If omitted, derived from block timestamp. */
+  deadline?: bigint;
+  /** Recipient of the output. Defaults to `account`. */
+  recipient?: Address;
+  /** Gas and transaction overrides. */
+  txOverrides?: TxOverrides;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link quoteSwapExactInViaRouter}.
+ */
+interface QuoteSwapExactInViaRouterParams {
+  /** Public client. */
+  client: PublicClient;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID. */
+  chainId: bigint;
+  /** Token to sell. `address(0)` for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of `tokenIn` to spend (must fit uint128). */
+  amountIn: bigint;
+  /** Slippage tolerance in bps (used to compute `amountOutMinimum`). */
+  slippageBps: bigint;
+  /** Optional block number for the quote. */
+  blockNumber?: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Quote result data (carried inside a `SimulationResult`).
+ */
+interface SwapExactInQuote {
+  /** Quoted output amount of `tokenOut`. */
+  amountOut: bigint;
+  /** Minimum acceptable output after applying slippage. */
+  amountOutMinimum: bigint;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
+  poolKey: PoolKey;
+  /** Quoter's gas estimate. */
+  gasEstimate: bigint;
+}
+/**
+ * Parameters for {@link swapExactOutViaRouter}.
+ */
+interface SwapExactOutViaRouterParams {
+  /** Public client for reads + receipts. */
+  client: PublicClient;
+  /** Wallet client for signing. */
+  walletClient: WalletClient;
+  /** Account address. */
+  account: Address;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID (selects per-chain Uniswap v4 addresses). */
+  chainId: bigint;
+  /** Token to sell (the pay token). `address(0)` (zero address) for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of the output token to receive (must fit uint128). */
+  amountOut: bigint;
+  /** Slippage tolerance in bps (e.g. 500n = 5%); caps the input. */
+  slippageBps: bigint;
+  /** Absolute deadline (unix seconds). If omitted, derived from block timestamp. */
+  deadline?: bigint;
+  /** Recipient of the output. Defaults to `account`. */
+  recipient?: Address;
+  /** Gas and transaction overrides. */
+  txOverrides?: TxOverrides;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link quoteSwapExactOutViaRouter}.
+ */
+interface QuoteSwapExactOutViaRouterParams {
+  /** Public client. */
+  client: PublicClient;
+  /** PanopticPool address — used to resolve the underlying v4 PoolKey. */
+  poolAddress: Address;
+  /** Chain ID. */
+  chainId: bigint;
+  /** Token to sell (the pay token). `address(0)` for native ETH. */
+  tokenIn: Address;
+  /** Exact amount of the output token to receive (must fit uint128). */
+  amountOut: bigint;
+  /** Slippage tolerance in bps (used to compute `amountInMaximum`). */
+  slippageBps: bigint;
+  /** Optional block number for the quote. */
+  blockNumber?: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Quote result data for an exact-out swap (carried inside a `SimulationResult`).
+ */
+interface SwapExactOutQuote {
+  /** Quoted input amount of `tokenIn` required for the exact output. */
+  amountIn: bigint;
+  /** Maximum acceptable input after applying slippage. */
+  amountInMaximum: bigint;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
+  poolKey: PoolKey;
+  /** Quoter's gas estimate. */
+  gasEstimate: bigint;
+}
+/**
+ * Parameters for {@link checkRouterApproval}.
+ */
+interface CheckRouterApprovalParams {
+  /** Public client. */
+  client: PublicClient;
+  /** Chain ID. */
+  chainId: bigint;
+  /** ERC20 token being spent (must not be native ETH). */
+  tokenIn: Address;
+  /** Token owner. */
+  owner: Address;
+  /** Amount that must be spendable. */
+  amount: bigint;
+  /** Override per-chain Uniswap v4 addresses (e.g. fork tests). */
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Result of {@link checkRouterApproval}.
+ */
+interface RouterApprovalStatus {
+  /** ERC20 → Permit2 allowance is insufficient. */
+  needsErc20Approval: boolean;
+  /** Permit2 → Universal Router allowance is insufficient or expired. */
+  needsPermit2Approval: boolean;
+  /** Current ERC20 → Permit2 allowance. */
+  erc20Allowance: bigint;
+  /** Current Permit2 → router allowance amount. */
+  permit2Amount: bigint;
+  /** Current Permit2 → router allowance expiration (unix seconds). */
+  permit2Expiration: bigint;
+}
+/**
+ * Parameters for {@link approveErc20ForPermit2}.
+ */
+interface ApproveErc20ForPermit2Params {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  chainId: bigint;
+  /** ERC20 token to approve to Permit2. */
+  tokenIn: Address;
+  /** Amount to approve. Defaults to uint256 max. */
+  amount?: bigint;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV4Addresses>;
+}
+/**
+ * Parameters for {@link approveRouterViaPermit2}.
+ */
+interface ApproveRouterViaPermit2Params {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  chainId: bigint;
+  /** ERC20 token the router is allowed to spend via Permit2. */
+  tokenIn: Address;
+  /** Amount to approve (must fit uint160). Defaults to uint160 max. */
+  amount?: bigint;
+  /** Allowance expiration (unix seconds, uint48). If omitted, block timestamp + 30 days. */
+  expiration?: bigint;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV4Addresses>;
+}
+
 //#endregion
 //#region src/uniswap/v4/router/permit2.d.ts
 /**
@@ -357,75 +1161,6 @@ declare function swapExactOutViaRouter(params: SwapExactOutViaRouterParams): Pro
  */
 declare function swapExactOutViaRouterAndWait(params: SwapExactOutViaRouterParams): Promise<TxReceipt>;
 
-//#endregion
-//#region src/uniswap/lpGreeks.d.ts
-/**
- * Greeks for plain (non-Panoptic) Uniswap v3/v4 concentrated-liquidity LP
- * positions. Pure math over on-chain position fields (liquidity + tick range)
- * and the pool's current price — no RPC, no protocol dependency.
- *
- * Units follow the Panoptic v2 greeks convention (see
- * `packages/sdk/src/panoptic/v2/greeks/index.ts`) so a caller can present LP
- * and Panoptic greeks side by side:
- *   - `value`  → numeraire-token smallest units
- *   - `delta`  → asset-token smallest units (the asset held by the LP)
- *   - `gamma`  → numeraire-token smallest units (dollar-gamma `P²·d²V/dP²`;
- *                always ≤ 0 because an LP is short gamma)
- *
- * `assetIndex` selects which token is the "asset" (the volatile leg being
- * hedged): `0` → token0 is the asset / token1 the numeraire; `1` → the reverse.
- *
- * @module uniswap/lpGreeks
- */
-/** Token amounts currently backing a concentrated-liquidity position. */
-interface LpAmounts {
-  /** token0 amount in its smallest units. */
-  amount0: bigint;
-  /** token1 amount in its smallest units. */
-  amount1: bigint;
-}
-/** Greeks of a Uniswap LP position in one asset frame (see module docs for units). */
-interface LpGreeks {
-  /** Position value in numeraire-token smallest units. */
-  value: bigint;
-  /** Delta in asset-token smallest units (the asset amount the LP is long). */
-  delta: bigint;
-  /** Dollar-gamma in numeraire-token smallest units; ≤ 0 (LP is short gamma). */
-  gamma: bigint;
-}
-/** Inputs describing a single LP position + the pool's current price. */
-interface LpGreeksInput {
-  /** Position liquidity `L`. */
-  liquidity: bigint;
-  /** Lower tick of the range. */
-  tickLower: bigint;
-  /** Upper tick of the range. */
-  tickUpper: bigint;
-  /** Pool's current tick. */
-  currentTick: bigint;
-  /** Which token is the asset: `0` (token0) or `1` (token1). */
-  assetIndex: 0 | 1;
-}
-/**
- * Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
- * at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
- * (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
- * clamped into the range, so out-of-range positions collapse to a single token.
- */
-declare function getAmountsForLiquidity(sqrtPriceX96: bigint, sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): LpAmounts;
-/**
- * Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
- * frame. See the module docs for the unit conventions.
- *
- * Closed forms (in-range, numeraire = token1 / asset = token0):
- *   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
- *   delta = amount0                            (= dV/dP)
- *   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
- * The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
- * Gamma is zero when the price is outside the range (no curvature there).
- */
-declare function getLpGreeks(input: LpGreeksInput): LpGreeks;
-
 //#endregion
 export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV3SwapCalldataArgs, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, InvalidSwapTokenError, LpAmounts, LpGreeks, LpGreeksInput, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactOutViaRouterParams, QuoteV3ExactInParams, QuoteV4ExactInByPoolKeyParams, QuoterUnavailableError, ResolveSwapRouteParams, ResolvedSwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UniswapV3Addresses, UniswapV4Addresses, UnsupportedChainError, V3ExactInQuote, V3_SWAP_EXACT_IN, V4ExactInQuote, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, getAmountsForLiquidity, getLpGreeks, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV3ExactIn, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
 //# sourceMappingURL=index.d.ts.map