@panoptic-eng/sdk 1.0.49 → 1.0.50

package/dist/uniswap/index.d.ts

@@ -1,25 +1,159 @@
+import Decimal from "decimal.js";
 import { Address, Hash, Hex, PublicClient, WalletClient } from "viem";
 
-//#region src/uniswap/lpGreeks.d.ts
+//#region src/uniswap/estimateLpFees.d.ts
+interface LpFeeCandle {
+  t: number;
+  o: number;
+  h: number;
+  l: number;
+  c: number;
+  /** Absolute swap volume (inputs + outputs), in raw token units. */
+  v0: string;
+  v1: string;
+  /** Historical active liquidity at the candle close, when available. */
+  liq?: string;
+}
+interface LpFeeRange {
+  tickLower: number;
+  tickUpper: number;
+  liquidity: bigint;
+}
 /**
-* 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. */
+ * Hypothetical added LP liquidity, with no compounding or price impact. Fees are raw
+ * token units. Bullish candles follow O→L→H→C; bearish candles O→H→L→C.
+ * Uniswap v3 deltas distribute absolute volume between inputs and outputs; only
+ * inputs pay fees. Split moves at every LP boundary, so overlapping ranges share
+ * the same denominator and out-of-range portions earn nothing.
+ *
+ * Closing historical liquidity approximates liquidity throughout a candle. If
+ * absent, infer it from volume / path deltas. Flat candles with volume use equal
+ * buy/sell flow and require historical liquidity; otherwise report them skipped.
+ * OHLC cannot recover unseen oscillations, exact swap ordering or liquidity changes.
+ */
+declare function estimateLpFees({
+  candles,
+  ranges,
+  feePips
+}: {
+  candles: readonly LpFeeCandle[];
+  ranges: readonly LpFeeRange[];
+  feePips: bigint;
+}): {
+  points: {
+    time: number;
+    fees0: bigint;
+    fees1: bigint;
+  }[];
+  skippedCandles: number;
+  inferredCandles: number;
+}; //#endregion
+//#region src/uniswap/lpDeposit.d.ts
+/** Uniswap mint principal in raw token units, rounded up per leg, plus 5% headroom. */
+declare function getLpDepositAmounts(ranges: readonly LpFeeRange[], sqrtPriceX96: bigint): {
+  amount0: bigint;
+  amount1: bigint;
+};
+/** Principal and separately identified funding headroom, in native token units. */
+declare function getLpDepositBreakdown(ranges: readonly LpFeeRange[], sqrtPriceX96: bigint): {
+  principal: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  buffer: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  total: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+};
+interface LpPositionFundingParams {
+  tokenId: bigint;
+  positionSize: bigint;
+  tickSpacing: bigint;
+  sqrtPriceX96: bigint;
+  /** Price used consistently to value funding and account collateral. */
+  valuationSqrtPriceX96: bigint;
+  quoteTokenIndex: 0 | 1;
+}
+/** Full deployed liquidity value; never a leveraged protocol margin estimate. */
+declare function getLpPositionFunding(params: LpPositionFundingParams): {
+  principalInQuote: bigint;
+  bufferInQuote: bigint;
+  totalInQuote: bigint;
+  principal: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  buffer: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  total: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+};
+/** Remaining deposit in the requested token mix, rounded up to cover the shortfall. */
+declare function getLpFundingDeposit({
+  funding,
+  availableInQuote,
+  minimumInQuote,
+  quoteTokenIndex,
+  valuationSqrtPriceX96,
+  quotePercent
+}: {
+  funding: ReturnType<typeof getLpPositionFunding>;
+  availableInQuote: bigint;
+  minimumInQuote?: bigint;
+  quoteTokenIndex: 0 | 1;
+  valuationSqrtPriceX96: bigint;
+  quotePercent?: bigint;
+}): {
+  requiredInQuote: bigint;
+  shortfallInQuote: bigint;
+  defaultQuotePercent: bigint;
+  amount0: bigint;
+  amount1: bigint;
+};
+/** Largest raw size funded by available collateral, including native-token rounding. */
+declare function getMaxLpPositionSize(params: Omit<LpPositionFundingParams, 'positionSize'> & {
+  availableInQuote: bigint;
+  minimumRequirement?: {
+    referenceSize: bigint;
+    requiredInQuote: bigint;
+  };
+}): bigint; //#endregion
+//#region src/uniswap/lpFeeReturn.d.ts
+/** Simple fee APR over the full selected viewport, without compounding. */
+declare function annualizeLpFeeReturn(feeReturnPercent: Decimal, durationSeconds: bigint): Decimal;
+/**
+ * Combine both fee tokens into a fee-only return on deployed LP capital.
+ * Value both capital and fees at the window's opening price: this keeps fee
+ * return flat when accrual stops and makes the ratio independent of quote
+ * orientation. Raw token amounts already account for differing decimals.
+ * Excludes principal price changes, impermanent loss and costs; not annualized.
+ * Returns undefined when the position has no representable deployed capital.
+ */
+declare function getLpFeeReturnSeries<T extends {
+  fees0: bigint;
+  fees1: bigint;
+}>({
+  points,
+  ranges,
+  startTick
+}: {
+  points: readonly T[];
+  ranges: readonly LpFeeRange[];
+  startTick: number;
+}): (T & {
+  feeReturnPercent: Decimal;
+})[] | undefined;
+
+//#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)
@@ -85,7 +219,9 @@ declare function getAmountsForLiquidity(sqrtPriceX96: bigint, sqrtRatioAX96: big
  * 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
+declare function getLpGreeks(input: LpGreeksInput): LpGreeks;
+
+//#endregion
 //#region src/uniswap/v3/addresses.d.ts
 interface UniswapV3Addresses {
   /** Uniswap v3 QuoterV2 — `quoteExactInputSingle` (revert/staticcall-based). */
@@ -110,6 +246,8 @@ declare function getUniswapV3Addresses(chainId: number | bigint, overrides?: Par
 //#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;
+/** Universal Router command byte for a v3 exact-out swap. */
+declare const V3_SWAP_EXACT_OUT = 1;
 /**
  * Universal Router recipient sentinel: the router maps `address(1)` to
  * `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
@@ -153,6 +291,26 @@ declare function buildV3SwapExecuteCalldata(args: BuildV3SwapCalldataArgs): {
   data: Hex;
   value: bigint;
 };
+interface BuildV3ExactOutSwapCalldataArgs {
+  tokenIn: Address;
+  tokenOut: Address;
+  fee: bigint;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  deadline: bigint;
+}
+/**
+ * Build the typed `execute(...)` args for an exact-out single-hop v3 swap.
+ * The v3 exact-out path is reversed: `tokenOut ++ fee ++ tokenIn`.
+ */
+declare function buildV3ExactOutSwapExecuteArgs(args: BuildV3ExactOutSwapCalldataArgs): {
+  args: readonly [Hex, readonly Hex[], bigint];
+  value: bigint;
+};
+declare function buildV3ExactOutSwapExecuteCalldata(args: BuildV3ExactOutSwapCalldataArgs): {
+  data: Hex;
+  value: bigint;
+};
 
 //#endregion
 //#region src/uniswap/v3/router/quote.d.ts
@@ -163,7 +321,6 @@ interface QuoteV3ExactInParams {
   tokenOut: Address;
   fee: bigint;
   amountIn: bigint;
-  /** Slippage tolerance in bps, used to compute `amountOutMinimum`. */
   slippageBps: bigint;
   blockNumber?: bigint;
   addresses?: Partial<UniswapV3Addresses>;
@@ -179,46 +336,26 @@ interface V3ExactInQuote {
  * 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;
+interface QuoteV3ExactOutParams {
+  client: PublicClient;
+  chainId: bigint;
+  tokenIn: Address;
+  tokenOut: Address;
+  fee: bigint;
+  amountOut: bigint;
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV3Addresses>;
+}
+interface V3ExactOutQuote {
+  amountIn: bigint;
+  amountInMaximum: bigint;
+  gasEstimate: bigint;
 }
 /**
- * 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.
+ * Quote an exact-out v3 swap. Returns `null` on revert (no pool / no liquidity).
  */
-declare function getUniswapV4Addresses(chainId: bigint, overrides?: Partial<UniswapV4Addresses>): UniswapV4Addresses;
+declare function quoteV3ExactOut(params: QuoteV3ExactOutParams): Promise<V3ExactOutQuote | null>;
 
 //#endregion
 //#region src/panoptic/v2/types/meta.d.ts
@@ -650,172 +787,47 @@ type SimulationResult<T> = {
 };
 
 //#endregion
-//#region src/uniswap/v4/router/encodeSwap.d.ts
+//#region src/uniswap/v4/addresses.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. */
-declare const SWAP_EXACT_IN_SINGLE = 6;
-/** v4 action: pay all of the input currency owed. */
-declare const SETTLE_ALL = 12;
-/** v4 action: take all of the output currency owed. */
-declare const TAKE_ALL = 15;
-/** v4 action: take an output currency to an explicit recipient. */
-
-/** v4 action: exact-out single-hop swap. */
-declare const SWAP_EXACT_OUT_SINGLE = 8;
-/** Universal Router command: sweep the router's token balance to a recipient. */
-declare const SWEEP = 4;
 /**
- * Arguments for {@link buildV4SwapExecuteCalldata}.
+ * Uniswap v4 contract addresses required for a Universal Router spot swap.
  */
-interface BuildV4SwapCalldataArgs {
-  /** The v4 PoolKey (currency0, currency1, fee, tickSpacing, hooks). */
-  poolKey: PoolKey;
-  /** Whether the swap goes currency0 → currency1. */
-  zeroForOne: boolean;
-  /** Exact input amount (uint128). */
-  amountIn: bigint;
-  /** Minimum acceptable output (uint128). */
-  amountOutMinimum: bigint;
-  /** Input token address (`address(0)` for native ETH). */
-  tokenIn: Address;
-  /** Output token address (`address(0)` for native ETH). */
-  tokenOut: Address;
-  /** Absolute deadline (unix seconds). */
-  deadline: bigint;
-  /**
-   * Recipient of native-ETH output. Required when `tokenOut` is `address(0)`,
-   * since the explicit-recipient `TAKE` action forwards the bought ETH there
-   * (the implicit-recipient `TAKE_ALL` would leave it held by the router).
-   */
-  recipient?: Address;
-  /** Hook data; defaults to `0x` (hook-less pools). */
-  hookData?: Hex;
+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;
 }
 /**
- * Build the typed `execute(...)` args + msg.value for an exact-in single-hop v4
- * swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
- *
- * When `tokenOut` is native ETH the explicit-recipient `TAKE` action forwards
- * the bought ETH to `recipient` (no trailing SWEEP is needed for exact-in).
- *
- * @returns `args` ready to spread into `execute` and the ETH `value` to send
- *   (= `amountIn` for native-ETH input, otherwise `0n`).
- */
-declare function buildV4SwapExecuteArgs(args: BuildV4SwapCalldataArgs): {
-  args: readonly [Hex, readonly Hex[], bigint];
-  value: bigint;
-};
-/**
- * Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
- * exact-in single-hop v4 swap.
- *
- * @returns The encoded calldata and the ETH `value` to send.
- */
-declare function buildV4SwapExecuteCalldata(args: BuildV4SwapCalldataArgs): {
-  data: Hex;
-  value: bigint;
-};
-/**
- * Arguments for {@link buildV4ExactOutSwapExecuteCalldata}.
+ * Canonical Permit2, identical across all chains.
  */
-interface BuildV4ExactOutSwapCalldataArgs {
-  /** The v4 PoolKey (currency0, currency1, fee, tickSpacing, hooks). */
-  poolKey: PoolKey;
-  /** Whether the swap goes currency0 → currency1. */
-  zeroForOne: boolean;
-  /** Exact output amount to receive (uint128). */
-  amountOut: bigint;
-  /** Maximum acceptable input to spend (uint128). */
-  amountInMaximum: bigint;
-  /** Input token address (`address(0)` for native ETH). */
-  tokenIn: Address;
-  /** Output token address (`address(0)` for native ETH). */
-  tokenOut: Address;
-  /** Absolute deadline (unix seconds). */
-  deadline: bigint;
-  /**
-   * Recipient of any swept native-ETH refund (only used for native-ETH input).
-   * Must be the payer; the leftover `amountInMaximum - actualInput` is returned
-   * here.
-   */
-  recipient: Address;
-  /** Hook data; defaults to `0x` (hook-less pools). */
-  hookData?: Hex;
-}
+declare const PERMIT2_ADDRESS: Address;
 /**
- * Build the typed `execute(...)` args + msg.value for an exact-out single-hop v4
- * swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
- *
- * For native-ETH input, `value` is `amountInMaximum` (an overpay) and a trailing
- * `SWEEP` action refunds the unused ETH to `recipient`. For ERC20 input, Permit2
- * pulls only the settled amount, so no SWEEP is appended and `value` is `0n`.
+ * Verified Uniswap v4 deployment addresses keyed by chainId.
  *
- * @returns `args` ready to spread into `execute` and the ETH `value` to send.
+ * 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 function buildV4ExactOutSwapExecuteArgs(args: BuildV4ExactOutSwapCalldataArgs): {
-  args: readonly [Hex, readonly Hex[], bigint];
-  value: bigint;
-};
+declare const UNISWAP_V4_ADDRESSES: Record<number, UniswapV4Addresses>;
 /**
- * Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
- * exact-out single-hop v4 swap.
+ * Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
  *
- * @returns The encoded calldata and the ETH `value` to send.
- */
-declare function buildV4ExactOutSwapExecuteCalldata(args: BuildV4ExactOutSwapCalldataArgs): {
-  data: Hex;
-  value: bigint;
-};
-
-//#endregion
-//#region src/uniswap/v4/router/errors.d.ts
-/**
- * The chain has no configured Uniswap v4 addresses and none were supplied via
- * overrides.
- */
-declare class UnsupportedChainError extends PanopticError {
-  readonly chainId: bigint;
-  readonly name = "UnsupportedChainError";
-  constructor(chainId: bigint, cause?: Error);
-}
-/**
- * `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
- */
-declare class InvalidSwapTokenError extends PanopticError {
-  readonly token: Address;
-  readonly currency0: Address;
-  readonly currency1: Address;
-  readonly name = "InvalidSwapTokenError";
-  constructor(token: Address, currency0: Address, currency1: Address, cause?: Error);
-}
-/**
- * An amount exceeds the uint128 range required by the v4 swap encoding.
- */
-declare class AmountExceedsUint128Error extends PanopticError {
-  readonly amount: bigint;
-  readonly name = "AmountExceedsUint128Error";
-  constructor(amount: bigint, cause?: Error);
-}
-/**
- * A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
- * output (or refund the input overpay), but no `recipient` was supplied.
- */
-declare class MissingSweepRecipientError extends PanopticError {
-  readonly name = "MissingSweepRecipientError";
-  constructor(cause?: Error);
-}
-/**
- * The V4Quoter is not available for the chain (no fallback in v1).
+ * @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 class QuoterUnavailableError extends PanopticError {
-  readonly chainId: bigint;
-  readonly name = "QuoterUnavailableError";
-  constructor(chainId: bigint, cause?: Error);
-}
+declare function getUniswapV4Addresses(chainId: bigint, overrides?: Partial<UniswapV4Addresses>): UniswapV4Addresses;
 
 //#endregion
 //#region src/uniswap/v4/router/types.d.ts
@@ -881,8 +893,8 @@ interface SwapExactInQuote {
   zeroForOne: boolean;
   /** Output token address (`address(0)` for native ETH). */
   tokenOut: Address;
-  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
-  poolKey: PoolKey;
+  /** Resolved v4 PoolKey (reused by the v4 swap calldata builder; absent for v3). */
+  poolKey?: PoolKey;
   /** Quoter's gas estimate. */
   gasEstimate: bigint;
 }
@@ -948,8 +960,8 @@ interface SwapExactOutQuote {
   zeroForOne: boolean;
   /** Output token address (`address(0)` for native ETH). */
   tokenOut: Address;
-  /** Resolved v4 PoolKey (reused by the swap calldata builder). */
-  poolKey: PoolKey;
+  /** Resolved v4 PoolKey (reused by the v4 swap calldata builder; absent for v3). */
+  poolKey?: PoolKey;
   /** Quoter's gas estimate. */
   gasEstimate: bigint;
 }
@@ -1018,6 +1030,244 @@ interface ApproveRouterViaPermit2Params {
   addresses?: Partial<UniswapV4Addresses>;
 }
 
+//#endregion
+//#region src/uniswap/v3/router/quoteViaRouter.d.ts
+interface QuoteSwapExactInViaV3RouterParams {
+  client: PublicClient;
+  poolAddress: Address;
+  chainId: bigint;
+  tokenIn: Address;
+  amountIn: bigint;
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV3Addresses>;
+}
+declare function quoteSwapExactInViaV3Router(params: QuoteSwapExactInViaV3RouterParams): Promise<SimulationResult<SwapExactInQuote>>;
+interface QuoteSwapExactOutViaV3RouterParams {
+  client: PublicClient;
+  poolAddress: Address;
+  chainId: bigint;
+  tokenIn: Address;
+  amountOut: bigint;
+  slippageBps: bigint;
+  blockNumber?: bigint;
+  addresses?: Partial<UniswapV3Addresses>;
+}
+declare function quoteSwapExactOutViaV3Router(params: QuoteSwapExactOutViaV3RouterParams): Promise<SimulationResult<SwapExactOutQuote>>;
+
+//#endregion
+//#region src/uniswap/v3/router/resolveRoute.d.ts
+interface ResolvedV3SwapRoute {
+  tokenIn: Address;
+  tokenOut: Address;
+  fee: bigint;
+  zeroForOne: boolean;
+}
+interface ResolveV3SwapRouteParams {
+  client: PublicClient;
+  poolAddress: Address;
+  tokenIn: Address;
+}
+declare function resolveV3SwapRoute(params: ResolveV3SwapRouteParams): Promise<ResolvedV3SwapRoute>;
+
+//#endregion
+//#region src/uniswap/v3/router/swap.d.ts
+interface SwapExactInViaV3RouterParams {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  poolAddress: Address;
+  chainId: bigint;
+  tokenIn: Address;
+  amountIn: bigint;
+  slippageBps: bigint;
+  deadline?: bigint;
+  recipient?: Address;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV3Addresses & UniswapV4Addresses>;
+}
+declare function swapExactInViaV3Router(params: SwapExactInViaV3RouterParams): Promise<TxResult>;
+interface SwapExactOutViaV3RouterParams {
+  client: PublicClient;
+  walletClient: WalletClient;
+  account: Address;
+  poolAddress: Address;
+  chainId: bigint;
+  tokenIn: Address;
+  amountOut: bigint;
+  slippageBps: bigint;
+  deadline?: bigint;
+  recipient?: Address;
+  txOverrides?: TxOverrides;
+  addresses?: Partial<UniswapV3Addresses & UniswapV4Addresses>;
+}
+declare function swapExactOutViaV3Router(params: SwapExactOutViaV3RouterParams): Promise<TxResult>;
+
+//#endregion
+//#region src/uniswap/v4/router/encodeSwap.d.ts
+/** Universal Router command byte for a v4 swap. */
+declare const V4_SWAP = 16;
+/** v4 action: exact-in single-hop swap. */
+declare const SWAP_EXACT_IN_SINGLE = 6;
+/** v4 action: pay all of the input currency owed. */
+declare const SETTLE_ALL = 12;
+/** v4 action: take all of the output currency owed. */
+declare const TAKE_ALL = 15;
+/** v4 action: take an output currency to an explicit recipient. */
+
+/** v4 action: exact-out single-hop swap. */
+declare const SWAP_EXACT_OUT_SINGLE = 8;
+/** Universal Router command: sweep the router's token balance to a recipient. */
+declare const SWEEP = 4;
+/**
+ * Arguments for {@link buildV4SwapExecuteCalldata}.
+ */
+interface BuildV4SwapCalldataArgs {
+  /** The v4 PoolKey (currency0, currency1, fee, tickSpacing, hooks). */
+  poolKey: PoolKey;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Exact input amount (uint128). */
+  amountIn: bigint;
+  /** Minimum acceptable output (uint128). */
+  amountOutMinimum: bigint;
+  /** Input token address (`address(0)` for native ETH). */
+  tokenIn: Address;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Absolute deadline (unix seconds). */
+  deadline: bigint;
+  /**
+   * Recipient of native-ETH output. Required when `tokenOut` is `address(0)`,
+   * since the explicit-recipient `TAKE` action forwards the bought ETH there
+   * (the implicit-recipient `TAKE_ALL` would leave it held by the router).
+   */
+  recipient?: Address;
+  /** Hook data; defaults to `0x` (hook-less pools). */
+  hookData?: Hex;
+}
+/**
+ * Build the typed `execute(...)` args + msg.value for an exact-in single-hop v4
+ * swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
+ *
+ * When `tokenOut` is native ETH the explicit-recipient `TAKE` action forwards
+ * the bought ETH to `recipient` (no trailing SWEEP is needed for exact-in).
+ *
+ * @returns `args` ready to spread into `execute` and the ETH `value` to send
+ *   (= `amountIn` for native-ETH input, otherwise `0n`).
+ */
+declare function buildV4SwapExecuteArgs(args: BuildV4SwapCalldataArgs): {
+  args: readonly [Hex, readonly Hex[], bigint];
+  value: bigint;
+};
+/**
+ * Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+ * exact-in single-hop v4 swap.
+ *
+ * @returns The encoded calldata and the ETH `value` to send.
+ */
+declare function buildV4SwapExecuteCalldata(args: BuildV4SwapCalldataArgs): {
+  data: Hex;
+  value: bigint;
+};
+/**
+ * Arguments for {@link buildV4ExactOutSwapExecuteCalldata}.
+ */
+interface BuildV4ExactOutSwapCalldataArgs {
+  /** The v4 PoolKey (currency0, currency1, fee, tickSpacing, hooks). */
+  poolKey: PoolKey;
+  /** Whether the swap goes currency0 → currency1. */
+  zeroForOne: boolean;
+  /** Exact output amount to receive (uint128). */
+  amountOut: bigint;
+  /** Maximum acceptable input to spend (uint128). */
+  amountInMaximum: bigint;
+  /** Input token address (`address(0)` for native ETH). */
+  tokenIn: Address;
+  /** Output token address (`address(0)` for native ETH). */
+  tokenOut: Address;
+  /** Absolute deadline (unix seconds). */
+  deadline: bigint;
+  /**
+   * Recipient of any swept native-ETH refund (only used for native-ETH input).
+   * Must be the payer; the leftover `amountInMaximum - actualInput` is returned
+   * here.
+   */
+  recipient: Address;
+  /** Hook data; defaults to `0x` (hook-less pools). */
+  hookData?: Hex;
+}
+/**
+ * Build the typed `execute(...)` args + msg.value for an exact-out single-hop v4
+ * swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
+ *
+ * For native-ETH input, `value` is `amountInMaximum` (an overpay) and a trailing
+ * `SWEEP` action refunds the unused ETH to `recipient`. For ERC20 input, Permit2
+ * pulls only the settled amount, so no SWEEP is appended and `value` is `0n`.
+ *
+ * @returns `args` ready to spread into `execute` and the ETH `value` to send.
+ */
+declare function buildV4ExactOutSwapExecuteArgs(args: BuildV4ExactOutSwapCalldataArgs): {
+  args: readonly [Hex, readonly Hex[], bigint];
+  value: bigint;
+};
+/**
+ * Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+ * exact-out single-hop v4 swap.
+ *
+ * @returns The encoded calldata and the ETH `value` to send.
+ */
+declare function buildV4ExactOutSwapExecuteCalldata(args: BuildV4ExactOutSwapCalldataArgs): {
+  data: Hex;
+  value: bigint;
+};
+
+//#endregion
+//#region src/uniswap/v4/router/errors.d.ts
+/**
+ * The chain has no configured Uniswap v4 addresses and none were supplied via
+ * overrides.
+ */
+declare class UnsupportedChainError extends PanopticError {
+  readonly chainId: bigint;
+  readonly name = "UnsupportedChainError";
+  constructor(chainId: bigint, cause?: Error);
+}
+/**
+ * `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
+ */
+declare class InvalidSwapTokenError extends PanopticError {
+  readonly token: Address;
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly name = "InvalidSwapTokenError";
+  constructor(token: Address, currency0: Address, currency1: Address, cause?: Error);
+}
+/**
+ * An amount exceeds the uint128 range required by the v4 swap encoding.
+ */
+declare class AmountExceedsUint128Error extends PanopticError {
+  readonly amount: bigint;
+  readonly name = "AmountExceedsUint128Error";
+  constructor(amount: bigint, cause?: Error);
+}
+/**
+ * A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
+ * output (or refund the input overpay), but no `recipient` was supplied.
+ */
+declare class MissingSweepRecipientError extends PanopticError {
+  readonly name = "MissingSweepRecipientError";
+  constructor(cause?: Error);
+}
+/**
+ * The V4Quoter is not available for the chain (no fallback in v1).
+ */
+declare class QuoterUnavailableError extends PanopticError {
+  readonly chainId: bigint;
+  readonly name = "QuoterUnavailableError";
+  constructor(chainId: bigint, cause?: Error);
+}
+
 //#endregion
 //#region src/uniswap/v4/router/permit2.d.ts
 /**
@@ -1162,5 +1412,5 @@ declare function swapExactOutViaRouter(params: SwapExactOutViaRouterParams): Pro
 declare function swapExactOutViaRouterAndWait(params: SwapExactOutViaRouterParams): Promise<TxReceipt>;
 
 //#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 };
+export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV3ExactOutSwapCalldataArgs, BuildV3SwapCalldataArgs, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, InvalidSwapTokenError, LpAmounts, LpFeeCandle, LpFeeRange, LpGreeks, LpGreeksInput, LpPositionFundingParams, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactInViaV3RouterParams, QuoteSwapExactOutViaRouterParams, QuoteSwapExactOutViaV3RouterParams, QuoteV3ExactInParams, QuoteV3ExactOutParams, QuoteV4ExactInByPoolKeyParams, QuoterUnavailableError, ResolveSwapRouteParams, ResolveV3SwapRouteParams, ResolvedSwapRoute, ResolvedV3SwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactInViaV3RouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, SwapExactOutViaV3RouterParams, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UniswapV3Addresses, UniswapV4Addresses, UnsupportedChainError, V3ExactInQuote, V3ExactOutQuote, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4ExactInQuote, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, estimateLpFees, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getMaxLpPositionSize, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, resolveSwapRoute, resolveV3SwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
 //# sourceMappingURL=index.d.ts.map