@exponent-labs/market-three-math 0.1.8 → 0.9.1

package/src/swapV2.ts

@@ -0,0 +1,999 @@
+/**
+ * CLMM Swap simulation V2
+ * Closely mirrors the Rust on-chain implementation from swap.rs
+ * Uses TicksWrapper to simulate RB-tree behavior
+ */
+import {
+  MarketThreeState,
+  SwapArgs,
+  SwapDirection,
+  SwapExactOutArgs,
+  SwapOutcomeV2,
+} from "./types"
+import {
+  EffSnap,
+  TicksWrapper,
+  calculateFeeRate,
+  getFeeFromAmount,
+  normalizedTimeRemaining,
+} from "./utilsV2"
+
+const BASE_POINTS = 10000
+
+/**
+ * Simulate a swap on the CLMM market (V2 - mirrors Rust closely)
+ * This is a pure function that does not mutate the market state
+ */
+export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): SwapOutcomeV2 {
+  const DEBUG = false // Set to true for debugging
+
+  const { financials, configurationOptions, ticks } = marketState
+  const secondsRemaining = Math.max(0, Number(financials.expirationTs) - Date.now() / 1000)
+
+  // 0) Snapshot of effective price parameters
+  const snapshot = new EffSnap(normalizedTimeRemaining(secondsRemaining), args.syExchangeRate)
+
+  // Wrap ticks for RB-tree-like operations
+  const ticksWrapper = new TicksWrapper(ticks)
+
+  // Current state in both spot and anchor coordinates
+  let currentPriceSpot = ticksWrapper.currentSpotPrice
+  let currentLeftBoundaryKey = ticksWrapper.currentTickKey
+
+  // Active liquidity at current interval (prefix-sum at left boundary)
+  let activeLiquidityU64 = ticksWrapper.currentPrefixSum
+  let activeLiquidityF64 = Number(activeLiquidityU64)
+
+  // Fees
+  const lpFeeRate = calculateFeeRate(configurationOptions.lnFeeRateRoot, secondsRemaining)
+  const protocolFeeBps = configurationOptions.treasuryFeeBps
+  const eps = configurationOptions.epsilonClamp
+
+  // Limits (optional spot)
+  if (args.priceSpotLimit !== undefined) {
+    if (args.direction === SwapDirection.PtToSy) {
+      if (args.priceSpotLimit < currentPriceSpot) {
+        throw new Error("Price limit violated: limit must be >= current price for PtToSy")
+      }
+    } else {
+      if (args.priceSpotLimit > currentPriceSpot) {
+        throw new Error("Price limit violated: limit must be <= current price for SyToPt")
+      }
+    }
+  }
+
+  // Accumulators
+  let amountOutNetU64 = 0
+  let feeLpOutU64 = 0
+  let feeProtocolOutU64 = 0
+  let amountInLeft = args.amountIn
+
+  if (DEBUG) {
+    console.log(`\nSwapV2 Debug: direction=${args.direction}, amountIn=${args.amountIn}`)
+    console.log(
+      `Initial: currentTickKey=${currentLeftBoundaryKey}, spotPrice=${currentPriceSpot}, activeLiq=${activeLiquidityU64}`,
+    )
+  }
+
+  // Main loop across contiguous intervals while we have input left
+  // Rust: while amount_in_left > 1
+  let iterations = 0
+  const MAX_ITERATIONS = 30
+
+  while (amountInLeft > 1 && iterations < MAX_ITERATIONS) {
+    iterations++
+
+    if (DEBUG) {
+      console.log(`\n--- Iteration ${iterations}, amountInLeft=${amountInLeft} ---`)
+    }
+
+    // Right boundary of current interval (must exist to have a half-open [left, right))
+    const rightBoundaryKeyOpt = ticksWrapper.successorKey(currentLeftBoundaryKey)
+
+    if (DEBUG) {
+      console.log(`rightBoundaryKey=${rightBoundaryKeyOpt}`)
+    }
+
+    // Handle case when no right boundary exists
+    if (rightBoundaryKeyOpt === null) {
+      if (args.direction === SwapDirection.SyToPt) {
+        // Cross boundary to the left (no right boundary means we need to go left)
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+        continue
+      } else {
+        break
+      }
+    }
+
+    const rightBoundaryKey = rightBoundaryKeyOpt
+
+    // Interval anchors (spot prices at boundaries)
+    const anchorULeft = ticksWrapper.getSpotPrice(currentLeftBoundaryKey)
+    const anchorURight = ticksWrapper.getSpotPrice(rightBoundaryKey)
+
+    // Effective price at current spot
+    const cEffOld = snapshot.getEffectivePrice(currentPriceSpot)
+
+    // Load principal ledgers for the interval (stored on the left boundary)
+    const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentLeftBoundaryKey)
+
+    // Y_max = L * (C(u_old) - C(u_right))
+    const cEffAtBoundary = snapshot.getEffectivePrice(anchorURight)
+    const yMaxToBoundaryF = activeLiquidityF64 * (cEffOld - cEffAtBoundary)
+
+    // PT_max_left = L * (u_old - u_left)
+    const duToLeft = currentPriceSpot - anchorULeft
+    const ptMaxToLeftF = activeLiquidityF64 * duToLeft
+
+    // Validate y_max and pt_max values before using them
+    if (
+      !Number.isFinite(yMaxToBoundaryF) ||
+      !Number.isFinite(ptMaxToLeftF) ||
+      yMaxToBoundaryF < 0 ||
+      ptMaxToLeftF < 0
+    ) {
+      const crossed = crossOneBoundary(
+        ticksWrapper,
+        args.direction,
+        args.direction === SwapDirection.PtToSy ? rightBoundaryKey : currentLeftBoundaryKey,
+        {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        },
+      )
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const lTradeF64 = computeKappaAndLTrade(
+      args.direction,
+      Number(principalPt),
+      Number(principalSy),
+      ptMaxToLeftF,
+      yMaxToBoundaryF,
+      activeLiquidityF64,
+    )
+
+    if (DEBUG) {
+      console.log(`  anchorULeft=${anchorULeft}, anchorURight=${anchorURight}`)
+      console.log(`  principalPt=${principalPt}, principalSy=${principalSy}`)
+      console.log(`  lTradeF64=${lTradeF64}`)
+    }
+
+    if (lTradeF64 === null || !Number.isFinite(lTradeF64) || lTradeF64 <= eps) {
+      const crossed = crossOneBoundary(
+        ticksWrapper,
+        args.direction,
+        args.direction === SwapDirection.PtToSy ? rightBoundaryKey : currentLeftBoundaryKey,
+        {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        },
+      )
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    if (args.direction === SwapDirection.PtToSy) {
+      // PT -> SY swap
+
+      // Final du in this interval
+      const duByInput = amountInLeft / lTradeF64
+      const duToBoundary = anchorURight - currentPriceSpot
+      const duActual = Math.min(duByInput, duToBoundary)
+
+      if (DEBUG) {
+        console.log(`  PtToSy: duByInput=${duByInput}, duToBoundary=${duToBoundary}, duActual=${duActual}`)
+        console.log(`  lTradeF64=${lTradeF64}`)
+      }
+
+      // Check if we need to cross boundary first (at boundary)
+      if (duToBoundary <= eps) {
+        // Cross boundary to unlock the next interval
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.PtToSy, rightBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+        continue
+      }
+
+      // Token flows for this segment (ceil for input to protect pool)
+      const ptInSegment = Math.ceil(lTradeF64 * duActual)
+      const anchorUNew = currentPriceSpot + duActual
+      const cEffNew = snapshot.getEffectivePrice(anchorUNew)
+      const syOutGrossF = lTradeF64 * (cEffOld - cEffNew)
+
+      // Clamp by SY principal
+      let syOutGrossU64 = Math.floor(syOutGrossF)
+      syOutGrossU64 = Math.min(syOutGrossU64, Number(principalSy))
+
+      if (DEBUG) {
+        console.log(`  ptInSegment=${ptInSegment}, syOutGrossU64=${syOutGrossU64}`)
+      }
+
+      // Fees in token_out (SY)
+      // For flash swaps, fee is based on YT value = (pt - sy × sy_exchange_rate) / sy_exchange_rate (in SY terms)
+      if (syOutGrossU64 > 0) {
+        let totalFeeOut: number
+        if (args.isCurrentFlashSwap) {
+          const syOutBase = syOutGrossU64 * args.syExchangeRate
+          const ytValueBase = ptInSegment - syOutBase
+          const ytValueSy = ytValueBase / args.syExchangeRate
+          totalFeeOut = getFeeFromAmount(Math.max(0, Math.floor(ytValueSy)), lpFeeRate)
+        } else {
+          totalFeeOut = getFeeFromAmount(syOutGrossU64, lpFeeRate)
+        }
+        const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
+        const lpFeeOut = totalFeeOut - protocolFeeOut
+        const syOutNet = syOutGrossU64 - totalFeeOut
+
+        // Accumulate to user
+        amountOutNetU64 += syOutNet
+        feeLpOutU64 += lpFeeOut
+        feeProtocolOutU64 += protocolFeeOut
+
+        // Mirror on-chain principal mutation for this interval:
+        // +PT input (gross), -SY output (gross)
+        ticksWrapper.setPrincipals(
+          currentLeftBoundaryKey,
+          principalPt + BigInt(ptInSegment),
+          principalSy - BigInt(syOutGrossU64),
+        )
+
+        // Consume input and advance state
+        amountInLeft -= ptInSegment
+        currentPriceSpot = anchorUNew
+      }
+
+      // If we hit boundary, cross
+      if (anchorURight - currentPriceSpot <= eps && amountInLeft > 1) {
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.PtToSy, rightBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+      }
+    } else {
+      // SY -> PT swap
+      const cEffLeft = snapshot.getEffectivePrice(anchorULeft)
+
+      // Final ΔC in this interval
+      const deltaCByInput = amountInLeft / lTradeF64
+      const deltaCToLeftBoundary = cEffLeft - cEffOld
+      const deltaCActual = Math.min(deltaCByInput, deltaCToLeftBoundary)
+
+      if (DEBUG) {
+        console.log(
+          `  SyToPt: deltaCByInput=${deltaCByInput}, deltaCToLeftBoundary=${deltaCToLeftBoundary}, deltaCActual=${deltaCActual}`,
+        )
+        console.log(`  lTradeF64=${lTradeF64}, eps=${eps}`)
+      }
+
+      // Check if we need to cross boundary first (at boundary)
+      if (deltaCToLeftBoundary <= eps) {
+        // Cross boundary to the left
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+        continue
+      }
+
+      // New effective price and spot after consuming ΔC
+      const cEffNew = cEffOld + deltaCActual
+      const spotPriceNew = snapshot.spotPriceFromEffectivePrice(cEffNew)
+
+      // Token flows
+      const syInSegmentF = lTradeF64 * (cEffNew - cEffOld)
+      const duAbs = currentPriceSpot - spotPriceNew
+      const ptOutGrossF = lTradeF64 * duAbs
+
+      // Clamp gross PT by available principal
+      let ptOutGrossU64 = Math.floor(ptOutGrossF)
+      ptOutGrossU64 = Math.min(ptOutGrossU64, Number(principalPt))
+      // ceil for input to protect pool
+      const syInSegmentU64 = Math.ceil(syInSegmentF)
+
+      if (DEBUG) {
+        console.log(`  spotPriceNew=${spotPriceNew}, duAbs=${duAbs}`)
+        console.log(`  ptOutGrossU64=${ptOutGrossU64}, syInSegmentU64=${syInSegmentU64}`)
+      }
+
+      // Match on-chain behavior: if no PT can be taken from this interval, cross and continue.
+      if (ptOutGrossU64 === 0) {
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+        continue
+      }
+
+      if (ptOutGrossU64 > 0) {
+        // Fees in token_out (PT)
+        // For flash swaps, fee is based on YT value = pt - sy × sy_exchange_rate
+        let totalFeeOut: number
+        if (args.isCurrentFlashSwap) {
+          const syInBase = syInSegmentU64 * args.syExchangeRate
+          const ytValue = ptOutGrossU64 - syInBase
+          totalFeeOut = getFeeFromAmount(Math.max(0, Math.floor(ytValue)), lpFeeRate)
+        } else {
+          totalFeeOut = getFeeFromAmount(ptOutGrossU64, lpFeeRate)
+        }
+        const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
+        const lpFeeOut = totalFeeOut - protocolFeeOut
+        const ptOutNet = ptOutGrossU64 - totalFeeOut
+
+        // Accumulate to user
+        amountOutNetU64 += ptOutNet
+        feeLpOutU64 += lpFeeOut
+        feeProtocolOutU64 += protocolFeeOut
+
+        // Mirror on-chain principal mutation for this interval:
+        // +SY input (gross), -PT output (gross)
+        ticksWrapper.setPrincipals(
+          currentLeftBoundaryKey,
+          principalPt - BigInt(ptOutGrossU64),
+          principalSy + BigInt(syInSegmentU64),
+        )
+      }
+
+      // Consume input and advance state
+      amountInLeft -= syInSegmentU64
+      currentPriceSpot = spotPriceNew
+
+      // If we hit boundary, cross
+      // Use effective price difference for consistency with pre-swap epsilon check
+      if (Math.abs(cEffNew - cEffLeft) <= eps && amountInLeft > 1) {
+        const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+          currentLeftBoundaryKey,
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+      }
+    }
+  }
+
+  const postMarketState: MarketThreeState = {
+    ...marketState,
+    ticks: ticksWrapper.toTicks(currentLeftBoundaryKey, currentPriceSpot, activeLiquidityU64),
+  }
+
+  return {
+    amountInConsumed: args.amountIn - amountInLeft,
+    amountOut: amountOutNetU64,
+    lpFeeChargedOutToken: feeLpOutU64,
+    protocolFeeChargedOutToken: feeProtocolOutU64,
+    finalSpotPrice: currentPriceSpot,
+    finalTickKey: currentLeftBoundaryKey, // This is now the key, not array index
+    postMarketState,
+  }
+}
+
+/**
+ * Simulate a swap exact-out on the CLMM market.
+ * Mirrors on-chain swap_exact_out (currently only SyToPt is supported).
+ */
+export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapExactOutArgs): SwapOutcomeV2 {
+  if (args.direction !== SwapDirection.SyToPt) {
+    throw new Error("Exact-out simulation only supports SyToPt")
+  }
+
+  const { financials, configurationOptions, ticks } = marketState
+  const secondsRemaining = Math.max(0, Number(financials.expirationTs) - Date.now() / 1000)
+  const snapshot = new EffSnap(normalizedTimeRemaining(secondsRemaining), args.syExchangeRate)
+
+  const ticksWrapper = new TicksWrapper(ticks)
+  let currentPriceSpot = ticksWrapper.currentSpotPrice
+  let currentLeftBoundaryKey = ticksWrapper.currentTickKey
+  let activeLiquidityU64 = ticksWrapper.currentPrefixSum
+  let activeLiquidityF64 = Number(activeLiquidityU64)
+
+  const lpFeeRate = calculateFeeRate(configurationOptions.lnFeeRateRoot, secondsRemaining)
+  const protocolFeeBps = configurationOptions.treasuryFeeBps
+  const eps = configurationOptions.epsilonClamp
+
+  if (args.priceSpotLimit !== undefined && args.priceSpotLimit > currentPriceSpot) {
+    throw new Error("Price limit violated: limit must be <= current price for SyToPt exact-out")
+  }
+
+  const amountOutTarget = Math.max(0, Math.floor(args.amountOut))
+  const amountInConstraint =
+    args.amountInConstraint !== undefined ? Math.max(0, Math.floor(args.amountInConstraint)) : undefined
+
+  if (amountOutTarget === 0) {
+    return {
+      amountInConsumed: 0,
+      amountOut: 0,
+      lpFeeChargedOutToken: 0,
+      protocolFeeChargedOutToken: 0,
+      finalSpotPrice: currentPriceSpot,
+      finalTickKey: currentLeftBoundaryKey,
+      postMarketState: marketState,
+    }
+  }
+
+  let amountOutLeft = amountOutTarget
+  let amountOutAccum = 0
+  let amountInConsumed = 0
+  let feeLpOutU64 = 0
+  let feeProtocolOutU64 = 0
+
+  let iterations = 0
+  const MAX_ITERATIONS = 1000
+
+  while (amountOutLeft > 2 && iterations < MAX_ITERATIONS) {
+    iterations++
+
+    const rightBoundaryKeyOpt = ticksWrapper.successorKey(currentLeftBoundaryKey)
+    const rightBoundaryKey = rightBoundaryKeyOpt
+
+    if (rightBoundaryKey === null) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const anchorULeft = ticksWrapper.getSpotPrice(currentLeftBoundaryKey)
+    const anchorURight = ticksWrapper.getSpotPrice(rightBoundaryKey)
+    const cEffOld = snapshot.getEffectivePrice(currentPriceSpot)
+    const cEffLeft = snapshot.getEffectivePrice(anchorULeft)
+    const deltaCToLeftBoundary = cEffLeft - cEffOld
+
+    if (!Number.isFinite(deltaCToLeftBoundary) || deltaCToLeftBoundary <= eps) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentLeftBoundaryKey)
+
+    const duToLeft = currentPriceSpot - anchorULeft
+    if (!Number.isFinite(duToLeft) || deltaCToLeftBoundary <= eps) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const ptMaxToLeftF = activeLiquidityF64 * duToLeft
+    const cEffRight = snapshot.getEffectivePrice(anchorURight)
+    const deltaCToRightBoundary = cEffOld - cEffRight
+    const yMaxToBoundaryF = activeLiquidityF64 * deltaCToRightBoundary
+
+    if (
+      !Number.isFinite(yMaxToBoundaryF) ||
+      !Number.isFinite(ptMaxToLeftF) ||
+      yMaxToBoundaryF < 0 ||
+      ptMaxToLeftF < 0
+    ) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const lTradeF64 = computeKappaAndLTrade(
+      SwapDirection.SyToPt,
+      Number(principalPt),
+      Number(principalSy),
+      ptMaxToLeftF,
+      yMaxToBoundaryF,
+      activeLiquidityF64,
+    )
+
+    if (lTradeF64 === null) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    let ptOutGrossBoundaryU64 = Math.floor(lTradeF64 * duToLeft)
+    ptOutGrossBoundaryU64 = Math.min(ptOutGrossBoundaryU64, Number(principalPt))
+
+    if (ptOutGrossBoundaryU64 === 0) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const totalFeeOutBoundary = getFeeFromAmount(ptOutGrossBoundaryU64, lpFeeRate)
+    const ptOutNetBoundary = Math.max(0, ptOutGrossBoundaryU64 - totalFeeOutBoundary)
+
+    if (ptOutNetBoundary === 0) {
+      const boundarySegment = calculateSwapSegment(
+        ptOutGrossBoundaryU64,
+        lTradeF64,
+        currentPriceSpot,
+        duToLeft,
+        anchorULeft,
+        snapshot,
+        cEffOld,
+        lpFeeRate,
+        args.isCurrentFlashSwap,
+      )
+
+      let syInBoundary = boundarySegment.syInSegmentU64
+      if (ptOutGrossBoundaryU64 > 0 && syInBoundary === 0) {
+        syInBoundary = 1
+      }
+
+      if (
+        amountInConstraint !== undefined &&
+        amountInConsumed + syInBoundary > amountInConstraint
+      ) {
+        throw new Error("Insufficient SY budget for exact-out trade")
+      }
+
+      amountInConsumed += syInBoundary
+
+      if (boundarySegment.totalFeeOut > 0) {
+        const protocolFeeOut = Math.floor((boundarySegment.totalFeeOut * protocolFeeBps) / BASE_POINTS)
+        const lpFeeOut = boundarySegment.totalFeeOut - protocolFeeOut
+        feeLpOutU64 += lpFeeOut
+        feeProtocolOutU64 += protocolFeeOut
+      }
+
+      if (syInBoundary > 0 || boundarySegment.ptOutGrossActual > 0) {
+        ticksWrapper.setPrincipals(
+          currentLeftBoundaryKey,
+          principalPt - BigInt(boundarySegment.ptOutGrossActual),
+          principalSy + BigInt(syInBoundary),
+        )
+      }
+
+      currentPriceSpot = boundarySegment.spotPriceNew
+
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+      continue
+    }
+
+    const targetNet = Math.min(amountOutLeft, ptOutNetBoundary)
+    const grossCandidate = findGrossForTargetNet(targetNet, 0, ptOutGrossBoundaryU64, (gross) =>
+      calculateNetPtOut(
+        gross,
+        lTradeF64,
+        currentPriceSpot,
+        duToLeft,
+        anchorULeft,
+        lpFeeRate,
+        args.isCurrentFlashSwap,
+        snapshot,
+        cEffOld,
+      ),
+    )
+
+    const segment = calculateSwapSegment(
+      grossCandidate,
+      lTradeF64,
+      currentPriceSpot,
+      duToLeft,
+      anchorULeft,
+      snapshot,
+      cEffOld,
+      lpFeeRate,
+      args.isCurrentFlashSwap,
+    )
+
+    let syInSegmentU64 = segment.syInSegmentU64
+    if (grossCandidate > 0 && syInSegmentU64 === 0) {
+      syInSegmentU64 = 1
+    }
+
+    if (
+      amountInConstraint !== undefined &&
+      amountInConsumed + syInSegmentU64 > amountInConstraint
+    ) {
+      throw new Error("Insufficient SY budget for exact-out trade")
+    }
+
+    const netActual = segment.ptOutGrossActual - segment.totalFeeOut
+    if (netActual < 0) {
+      throw new Error("Exact-out net underflow")
+    }
+    if (netActual > amountOutLeft) {
+      throw new Error("Exact-out net exceeded remaining target")
+    }
+    amountOutLeft -= netActual
+    amountOutAccum += netActual
+    amountInConsumed += syInSegmentU64
+
+    const protocolFeeOut = Math.floor((segment.totalFeeOut * protocolFeeBps) / BASE_POINTS)
+    const lpFeeOut = segment.totalFeeOut - protocolFeeOut
+    feeLpOutU64 += lpFeeOut
+    feeProtocolOutU64 += protocolFeeOut
+
+    ticksWrapper.setPrincipals(
+      currentLeftBoundaryKey,
+      principalPt - BigInt(segment.ptOutGrossActual),
+      principalSy + BigInt(syInSegmentU64),
+    )
+
+    currentPriceSpot = segment.spotPriceNew
+
+    const cEffNew = snapshot.getEffectivePrice(currentPriceSpot)
+    if (
+      amountOutLeft > 2 &&
+      (Math.abs(cEffNew - cEffLeft) <= eps || segment.ptOutGrossActual === ptOutGrossBoundaryU64)
+    ) {
+      const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
+        currentLeftBoundaryKey,
+        currentPriceSpot,
+        activeLiquidityU64,
+        activeLiquidityF64,
+      })
+      if (!crossed) break
+      currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+      currentPriceSpot = crossed.currentPriceSpot
+      activeLiquidityU64 = crossed.activeLiquidityU64
+      activeLiquidityF64 = crossed.activeLiquidityF64
+    }
+  }
+
+  if (amountOutLeft > 2) {
+    throw new Error("Insufficient PT output for exact-out trade")
+  }
+
+  const postMarketState: MarketThreeState = {
+    ...marketState,
+    ticks: ticksWrapper.toTicks(currentLeftBoundaryKey, currentPriceSpot, activeLiquidityU64),
+  }
+
+  return {
+    amountInConsumed,
+    amountOut: amountOutAccum,
+    lpFeeChargedOutToken: feeLpOutU64,
+    protocolFeeChargedOutToken: feeProtocolOutU64,
+    finalSpotPrice: currentPriceSpot,
+    finalTickKey: currentLeftBoundaryKey,
+    postMarketState,
+  }
+}
+
+function computeKappaAndLTrade(
+  direction: SwapDirection,
+  principalPtInInterval: number,
+  principalSyInInterval: number,
+  ptMaxToLeftF: number,
+  yMaxToBoundaryF: number,
+  activeLiquidityF64: number,
+): number | null {
+  const isPtOnlyRange = yMaxToBoundaryF <= 0 || principalSyInInterval === 0
+  const isSyOnlyRange = ptMaxToLeftF <= 0 || principalPtInInterval === 0
+
+  let kappaSy: number
+  let kappaPt: number
+
+  if (direction === SwapDirection.SyToPt) {
+    kappaPt = isSyOnlyRange
+      ? 0
+      : ptMaxToLeftF > 0
+        ? principalPtInInterval / ptMaxToLeftF
+        : Infinity
+    kappaSy = isPtOnlyRange
+      ? 1
+      : yMaxToBoundaryF > 0
+        ? principalSyInInterval / yMaxToBoundaryF
+        : Infinity
+  } else {
+    kappaSy = isPtOnlyRange
+      ? 0
+      : yMaxToBoundaryF > 0
+        ? principalSyInInterval / yMaxToBoundaryF
+        : Infinity
+    kappaPt = isSyOnlyRange
+      ? 1
+      : ptMaxToLeftF > 0
+        ? principalPtInInterval / ptMaxToLeftF
+        : Infinity
+  }
+
+  const kappa = Math.min(kappaPt, kappaSy, 1)
+  if (!Number.isFinite(kappa) || kappa <= 0) {
+    return null
+  }
+
+  const lTradeF64 = activeLiquidityF64 * kappa
+  if (!Number.isFinite(lTradeF64) || lTradeF64 <= 0) {
+    return null
+  }
+
+  return lTradeF64
+}
+
+function findGrossForTargetNet(
+  targetNet: number,
+  minGross: number,
+  maxGross: number,
+  calculateNet: (gross: number) => number,
+): number {
+  if (minGross >= maxGross) {
+    return minGross
+  }
+
+  let left = minGross
+  let right = maxGross
+  let bestGross = minGross
+
+  while (left <= right) {
+    const mid = left + Math.floor((right - left) / 2)
+    const net = calculateNet(mid)
+
+    if (net === targetNet) {
+      return mid
+    }
+
+    if (net < targetNet) {
+      bestGross = mid
+      left = mid + 1
+    } else {
+      if (mid === 0) {
+        break
+      }
+      right = mid - 1
+    }
+  }
+
+  return bestGross
+}
+
+function calculateNetPtOut(
+  grossCandidate: number,
+  lTradeF64: number,
+  currentPriceSpot: number,
+  duToLeft: number,
+  anchorULeft: number,
+  lpFeeRate: number,
+  isCurrentFlashSwap: boolean,
+  snapshot: EffSnap,
+  cEffOld: number,
+): number {
+  const duCandidate = grossCandidate / lTradeF64
+  const duClamped = Math.min(duCandidate, duToLeft)
+  let spotPriceNew = currentPriceSpot - duClamped
+  if (spotPriceNew < anchorULeft) {
+    spotPriceNew = anchorULeft
+  }
+
+  const ptOutGrossActual = Math.max(
+    0,
+    Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)),
+  )
+
+  const totalFeeOut = isCurrentFlashSwap
+    ? (() => {
+        const cEffNew = snapshot.getEffectivePrice(spotPriceNew)
+        const syInSegmentF = lTradeF64 * (cEffNew - cEffOld)
+        const syInBase = Math.ceil(syInSegmentF) * snapshot.syExchangeRate
+        const ytValue = ptOutGrossActual - syInBase
+        return getFeeFromAmount(Math.max(0, Math.floor(ytValue)), lpFeeRate)
+      })()
+    : getFeeFromAmount(ptOutGrossActual, lpFeeRate)
+
+  return Math.max(0, ptOutGrossActual - totalFeeOut)
+}
+
+function calculateSwapSegment(
+  grossCandidate: number,
+  lTradeF64: number,
+  currentPriceSpot: number,
+  duToLeft: number,
+  anchorULeft: number,
+  snapshot: EffSnap,
+  cEffOld: number,
+  lpFeeRate: number,
+  isCurrentFlashSwap: boolean,
+): {
+  spotPriceNew: number
+  syInSegmentU64: number
+  ptOutGrossActual: number
+  totalFeeOut: number
+} {
+  const duCandidate = grossCandidate / lTradeF64
+  const duClamped = Math.min(duCandidate, duToLeft)
+  let spotPriceNew = currentPriceSpot - duClamped
+  if (spotPriceNew < anchorULeft) {
+    spotPriceNew = anchorULeft
+  }
+
+  const cEffNew = snapshot.getEffectivePrice(spotPriceNew)
+  const syInSegmentF = lTradeF64 * (cEffNew - cEffOld)
+  const syInSegmentU64 = Math.max(0, Math.ceil(syInSegmentF))
+  const ptOutGrossActual = Math.max(
+    0,
+    Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)),
+  )
+
+  const normalFee = getFeeFromAmount(ptOutGrossActual, lpFeeRate)
+  const syInBase = Math.ceil(syInSegmentF) * snapshot.syExchangeRate
+  const ytValue = ptOutGrossActual - syInBase
+  const flashFee = getFeeFromAmount(Math.max(0, Math.floor(ytValue)), lpFeeRate)
+  const totalFeeOut = isCurrentFlashSwap ? flashFee : normalFee
+
+  return {
+    spotPriceNew,
+    syInSegmentU64,
+    ptOutGrossActual,
+    totalFeeOut,
+  }
+}
+
+/**
+ * State during swap iteration
+ */
+interface SwapState {
+  currentLeftBoundaryKey: number
+  currentPriceSpot: number
+  activeLiquidityU64: bigint
+  activeLiquidityF64: number
+}
+
+/**
+ * Cross one boundary and update core state
+ * Mirrors Rust's cross_one_boundary_and_update_core
+ */
+function crossOneBoundary(
+  ticksWrapper: TicksWrapper,
+  direction: SwapDirection,
+  boundaryKeyToCross: number,
+  state: SwapState,
+): SwapState | null {
+  // Get liquidity_net at the boundary we're crossing
+  const deltaNetI64 = ticksWrapper.getLiquidityNet(boundaryKeyToCross)
+  const lOldI64 = state.activeLiquidityU64
+
+  // Update active liquidity
+  let lNewI64: bigint
+  if (direction === SwapDirection.PtToSy) {
+    // Crossing upward boundary: add liquidity_net
+    lNewI64 = lOldI64 + deltaNetI64
+  } else {
+    // Crossing downward boundary: subtract liquidity_net
+    lNewI64 = lOldI64 - deltaNetI64
+  }
+
+  // Ensure non-negative
+  if (lNewI64 < 0n) {
+    lNewI64 = 0n
+  }
+
+  // Move spot to the boundary we cross
+  const boundarySpot = ticksWrapper.getSpotPrice(boundaryKeyToCross)
+
+  // Advance current left boundary key
+  let newLeftBoundaryKey: number | null
+  if (direction === SwapDirection.PtToSy) {
+    // Moving right: new left boundary is the crossed boundary
+    newLeftBoundaryKey = boundaryKeyToCross
+  } else {
+    // Moving left: new left boundary is predecessor of current
+    newLeftBoundaryKey = ticksWrapper.predecessorKey(state.currentLeftBoundaryKey)
+  }
+
+  if (newLeftBoundaryKey === null) {
+    return null // End of range
+  }
+
+  return {
+    currentLeftBoundaryKey: newLeftBoundaryKey,
+    currentPriceSpot: boundarySpot,
+    activeLiquidityU64: lNewI64,
+    activeLiquidityF64: Number(lNewI64),
+  }
+}