@exponent-labs/market-three-math 0.1.8

package/src/liquidityHistogram.ts

@@ -0,0 +1,192 @@
+/**
+ * Liquidity histogram utilities for CLMM markets
+ * Builds a histogram of liquidity distribution across tick_space aligned bins
+ */
+
+import { Ticks } from "@exponent-labs/exponent-fetcher"
+import {  convertApyBpToApy, getSuccessorTickKey } from "./utils"
+
+export interface LiquidityHistogramBin {
+  /** APY for this bin (tick_space aligned) */
+  apy: number
+  /** Principal PT amount in this bin */
+  principalPt: number
+  /** Principal SY amount in this bin */
+  principalSy: number
+  /** Tick key (basis points) */
+  tickKey: number
+}
+
+/**
+ * Build a liquidity distribution histogram with tick_space aligned bins
+ *
+ * This function projects liquidity from created ticks onto virtual bins aligned
+ * to tickSpace. The projection logic is analogous to project_anchor_shares_to_current_ticks
+ * from remove_liquidity.rs, where liquidity is distributed proportionally based on
+ * the spot price ranges.
+ *
+ * Example:
+ * - Created ticks at: 1%, 5%, 6%
+ * - tickSpace: 1% (100 basis points)
+ * - Result bins: 1%, 2%, 3%, 4%, 5%, 6%
+ *
+ * For a tick interval [1%, 5%] with principalPt=1000:
+ * - Range: 5% - 1% = 4%
+ * - Bin [1%, 2%]: gets 1000 * (2%-1%)/(5%-1%) = 250
+ * - Bin [2%, 3%]: gets 1000 * (3%-2%)/(5%-1%) = 250
+ * - Bin [3%, 4%]: gets 1000 * (4%-3%)/(5%-1%) = 250
+ * - Bin [4%, 5%]: gets 1000 * (5%-4%)/(5%-1%) = 250
+ *
+ * @param ticks - The market's ticks state
+ * @param tickSpace - The tick spacing in basis points (e.g., 100 for 1%)
+ * @returns Array of histogram bins aligned to tickSpace
+ */
+export function buildLiquidityHistogram(ticks: Ticks, tickSpace: number): LiquidityHistogramBin[] {
+  const histogram: LiquidityHistogramBin[] = []
+
+  // Edge case: no ticks created yet
+  if (!ticks.ticksTree.length || ticks.ticksTree.length === 0) {
+    return histogram
+  }
+
+  // Find min and max tick keys (apyBasePoints)
+  const tickKeys = ticks.ticksTree.map((t) => t.apyBasePoints).sort((a, b) => a - b)
+  const minTickKey = tickKeys[0]
+  const maxTickKey = tickKeys[tickKeys.length - 1]
+
+  // Align min and max to tickSpace boundaries
+  const minAlignedKey = Math.floor(minTickKey / tickSpace) * tickSpace
+  const maxAlignedKey = Math.ceil(maxTickKey / tickSpace) * tickSpace
+
+  // Create map of created ticks for fast lookup
+  const tickMap = new Map<number, (typeof ticks.ticksTree)[0]>()
+  for (const tick of ticks.ticksTree) {
+    tickMap.set(tick.apyBasePoints, tick)
+  }
+
+  // Create bins map (virtual ticks aligned to tickSpace)
+  const binMap = new Map<number, { principalPt: number; principalSy: number }>()
+
+  // Initialize all bins from min to max with tickSpace steps
+  for (let binKey = minAlignedKey; binKey <= maxAlignedKey; binKey += tickSpace) {
+    binMap.set(binKey, { principalPt: 0, principalSy: 0 })
+  }
+
+  // Iterate through all created tick intervals and project liquidity
+  let currentTickKey: number | null = minTickKey
+
+  while (currentTickKey !== null) {
+    const currentTick = tickMap.get(currentTickKey)
+    const nextTickKey = getSuccessorTickKey(ticks, currentTickKey)
+
+    if (currentTick) {
+      // Principal amounts in this tick
+      const intervalPrincipalPt = currentTick.principalPt
+      const intervalPrincipalSy = currentTick.principalSy
+
+      // Skip if no liquidity in this tick
+      if (intervalPrincipalPt > 0 || intervalPrincipalSy > 0) {
+        if (nextTickKey !== null) {
+          // We have an interval [currentTickKey, nextTickKey)
+          const intervalStartKey = currentTickKey
+          const intervalEndKey = nextTickKey
+          const fullRange = intervalEndKey - intervalStartKey
+
+          // Find all bins that intersect with this interval
+          const firstBinKey = Math.ceil(intervalStartKey / tickSpace) * tickSpace
+          const lastBinKey = Math.floor((intervalEndKey - 1) / tickSpace) * tickSpace
+
+          // Special case: interval is smaller than tickSpace
+          if (firstBinKey > lastBinKey) {
+            // Put all liquidity in the bin that contains the interval start
+            const containingBinKey = Math.floor(intervalStartKey / tickSpace) * tickSpace
+            const bin = binMap.get(containingBinKey)
+            if (bin) {
+              bin.principalPt += Number(intervalPrincipalPt)
+              bin.principalSy += Number(intervalPrincipalSy)
+            }
+          } else {
+            // Distribute proportionally across bins
+            for (let binKey = firstBinKey; binKey <= lastBinKey; binKey += tickSpace) {
+              const bin = binMap.get(binKey)
+              if (!bin) continue
+
+              // Calculate the range of this bin that overlaps with the interval
+              const binStart = Math.max(binKey, intervalStartKey)
+              const binEnd = Math.min(binKey + tickSpace, intervalEndKey)
+              const binRange = binEnd - binStart
+
+              // Proportional share of liquidity for this bin
+              const share = binRange / fullRange
+
+              bin.principalPt += Math.floor(Number(intervalPrincipalPt) * share)
+              bin.principalSy += Math.floor(Number(intervalPrincipalSy) * share)
+            }
+          }
+        } else {
+          // Last tick - put all liquidity in its bin
+          const containingBinKey = Math.floor(currentTickKey / tickSpace) * tickSpace
+          const bin = binMap.get(containingBinKey)
+          if (bin) {
+            bin.principalPt += Number(intervalPrincipalPt)
+            bin.principalSy += Number(intervalPrincipalSy)
+          }
+        }
+      }
+    }
+
+    currentTickKey = nextTickKey
+  }
+
+  // Convert map to sorted array
+  const sortedBinKeys = Array.from(binMap.keys()).sort((a, b) => a - b)
+
+  for (const binKey of sortedBinKeys) {
+    const bin = binMap.get(binKey)!
+
+    // Only include bins with non-zero liquidity
+    if (bin.principalPt > 0 || bin.principalSy > 0) {
+      histogram.push({
+        apy: convertApyBpToApy(binKey),
+        principalPt: bin.principalPt,
+        principalSy: bin.principalSy,
+        tickKey: binKey,
+      })
+    }
+  }
+
+  return histogram
+}
+
+/**
+ * Build a simplified histogram without projection
+ *
+ * This version simply returns the principal amounts at each created tick,
+ * without projecting onto tickSpace-aligned bins.
+ *
+ * @param ticks - The market's ticks state
+ * @returns Array of histogram bins for created ticks only
+ */
+export function buildLiquidityHistogramSimple(ticks: Ticks): LiquidityHistogramBin[] {
+  const histogram: LiquidityHistogramBin[] = []
+
+  if (!ticks.ticksTree || ticks.ticksTree.length === 0) {
+    return histogram
+  }
+
+  // Sort by apyBasePoints and iterate
+  const sortedTicks = [...ticks.ticksTree].sort((a, b) => a.apyBasePoints - b.apyBasePoints)
+
+  for (const tick of sortedTicks) {
+    if (tick.principalPt > 0 || tick.principalSy > 0) {
+      histogram.push({
+        apy: convertApyBpToApy(tick.apyBasePoints),
+        principalPt: Number(tick.principalPt),
+        principalSy: Number(tick.principalSy),
+        tickKey: tick.apyBasePoints,
+      })
+    }
+  }
+
+  return histogram
+}

package/src/quote.ts

@@ -0,0 +1,128 @@
+import { Tick, Ticks } from "@exponent-labs/exponent-fetcher"
+
+import { simulateSwap } from "./swap"
+import { MarketThreeState, SwapDirection, SwapOutcome } from "./types"
+import { simulateBuyYtWithSyIn, simulateSellYt } from "./ytTrades"
+
+export enum QuoteDirection {
+  PtToSy = "PtToSy",
+  SyToPt = "SyToPt",
+  YtToSy = "YtToSy",
+  SyToYt = "SyToYt",
+}
+
+export type Quote = {
+  amountIn: number
+  amountOut: number
+  lpFee: number
+  protocolFee: number
+}
+
+/**
+ * Calculate the expected output for a given input amount
+ * This is a convenience wrapper around simulateSwap
+ */
+export function getSwapQuote(marketState: MarketThreeState, amountIn: number, direction: QuoteDirection): Quote {
+  //? Calculate correct currentTick index
+  //TODO Remove this logic when contract is updated!!!
+  const currentTickIndex = calculateCurrentTickIndex(marketState.ticks)
+
+  const marketStateMutated: MarketThreeState = {
+    ...marketState,
+    ticks: {
+      ...marketState.ticks,
+      currentTick: currentTickIndex,
+    },
+  }
+
+  if (direction === QuoteDirection.PtToSy) {
+    const { amountInConsumed, amountOut, lpFeeChargedOutToken, protocolFeeChargedOutToken } = simulateSwap(
+      marketStateMutated,
+      {
+        direction: SwapDirection.PtToSy,
+        amountIn,
+        syExchangeRate: marketStateMutated.currentSyExchangeRate,
+        isCurrentFlashSwap: false,
+      },
+    )
+    return {
+      amountIn: amountInConsumed,
+      amountOut: amountOut,
+      lpFee: lpFeeChargedOutToken,
+      protocolFee: protocolFeeChargedOutToken,
+    }
+  }
+  if (direction === QuoteDirection.SyToPt) {
+    const { amountInConsumed, amountOut, lpFeeChargedOutToken, protocolFeeChargedOutToken } = simulateSwap(
+      marketStateMutated,
+      {
+        direction: SwapDirection.SyToPt,
+        amountIn,
+        syExchangeRate: marketStateMutated.currentSyExchangeRate,
+        isCurrentFlashSwap: false,
+      },
+    )
+    return {
+      amountIn: amountInConsumed,
+      amountOut: amountOut,
+      lpFee: lpFeeChargedOutToken,
+      protocolFee: protocolFeeChargedOutToken,
+    }
+  }
+
+  if (direction === QuoteDirection.YtToSy) {
+    const { ytIn, netSyReceived, lpFee, protocolFee } = simulateSellYt(marketStateMutated, {
+      ytIn: amountIn,
+      syExchangeRate: marketStateMutated.currentSyExchangeRate,
+    })
+
+    return {
+      amountIn: ytIn,
+      amountOut: netSyReceived,
+      lpFee: lpFee,
+      protocolFee: protocolFee,
+    }
+  }
+
+  if (direction === QuoteDirection.SyToYt) {
+    const { ytOut, netSyCost, lpFee, protocolFee } = simulateBuyYtWithSyIn(marketStateMutated, {
+      syIn: amountIn,
+      syExchangeRate: marketStateMutated.currentSyExchangeRate,
+    })
+
+    return {
+      amountIn: netSyCost,
+      amountOut: ytOut,
+      lpFee: lpFee,
+      protocolFee,
+    }
+  }
+
+  throw new Error(`Unknown quote direction: ${direction}`)
+}
+
+/**
+ * Calculate the correct currentTick index for the market state
+ *
+ * IMPORTANT: currentTick must be a 1-based ARRAY INDEX, not apyBasePoints!
+ * The simulateSwap function uses findTickByIndex which does: ticksTree.at(index - 1)
+ *
+ * @returns The 1-based array index of the tick where impliedRate <= currentSpotPrice
+ */
+function calculateCurrentTickIndex(ticksData: Ticks): number {
+  // Find the tick with highest impliedRate <= currentSpotPrice
+  let currentTickApyBps = ticksData.ticksTree[0]?.apyBasePoints || 0
+
+  for (const tick of ticksData.ticksTree) {
+    const tickRate = Number(tick.impliedRate)
+    if (tickRate <= ticksData.currentSpotPrice) {
+      currentTickApyBps = tick.apyBasePoints
+    }
+  }
+
+  // Find the array index (0-based) of this tick
+  const arrayIndex = ticksData.ticksTree.findIndex((t: Tick) => t.apyBasePoints === currentTickApyBps)
+
+  // Convert to 1-based index for simulateSwap
+  return arrayIndex !== -1 ? arrayIndex + 1 : 1
+}

package/src/swap.ts

@@ -0,0 +1,299 @@
+/**
+ * CLMM Swap simulation - V2
+ * Updated to match the latest Rust on-chain implementation
+ * Key changes:
+ * - Uses currentPrefixSum for active liquidity
+ * - Implements kappa scaling for principal-limited swaps
+ * - Correct tick key conversions (1e6 basis)
+ */
+import { MarketThreeState, SwapArgs, SwapDirection, SwapOutcome } from "./types"
+import {
+  EffSnap,
+  bigIntMax,
+  bigIntMin,
+  calculateFeeRate,
+  findTickByIndex,
+  findTickByKey,
+  getFeeFromAmount,
+  getImpliedRate,
+  getPredecessorTickKey,
+  getSuccessorTickKey,
+  normalizedTimeRemaining,
+} from "./utils"
+
+const BASE_POINTS = 10000
+
+/**
+ * Simulate a swap on the CLMM market
+ * This is a pure function that does not mutate the market state
+ * Returns the swap outcome including amounts and final state
+ */
+export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): SwapOutcome {
+  const { financials, configurationOptions, ticks } = marketState
+  const secondsRemaining = Math.max(0, Number(financials.expirationTs) - Date.now() / 1000)
+
+  // Create effective price snapshot
+  const snapshot: EffSnap = new EffSnap(normalizedTimeRemaining(secondsRemaining), args.syExchangeRate)
+
+  // Current state
+  let currentPriceSpot: number = ticks.currentSpotPrice
+  let currentLeftBoundaryIndex: number = ticks.currentTick
+
+  // Use currentPrefixSum if available, otherwise fall back to calculating it
+  let activeLiquidityU64: bigint = ticks.currentPrefixSum ?? 0n
+  let activeLiquidityF64: number = Number(activeLiquidityU64)
+
+  // Fees
+  const lpFeeRate: number = calculateFeeRate(configurationOptions.lnFeeRateRoot, secondsRemaining)
+  const protocolFeeBps = configurationOptions.treasuryFeeBps
+
+  // Check price limits
+  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 amountOutNet: number = 0
+  let feeLpOut: number = 0
+  let feeProtocolOut: number = 0
+  let amountInLeft: number = args.amountIn
+
+  // Main loop across contiguous intervals
+  let iterations: number = 0
+  const MAX_ITERATIONS: number = 1000 // Safety limit
+  const debug = false // Set to true for debugging
+
+  if (debug) console.log(`\nSwap Debug: direction=${args.direction}, amountIn=${args.amountIn}`)
+  if (debug)
+    console.log(
+      `Initial: currentTick=${currentLeftBoundaryIndex}, spotPrice=${currentPriceSpot}, activeLiq=${activeLiquidityU64}`,
+    )
+
+  while (amountInLeft > 0 && iterations < MAX_ITERATIONS) {
+    iterations++
+    if (debug) console.log(`\n--- Iteration ${iterations}, amountInLeft=${amountInLeft} ---`)
+
+    // Get right boundary of current interval
+    const rightBoundaryIndexOpt = findTickByKey(ticks, getSuccessorTickKey(ticks, currentLeftBoundaryIndex))?.index
+    if (debug) console.log(`rightBoundary=${rightBoundaryIndexOpt}`)
+
+    if (rightBoundaryIndexOpt === null) {
+      if (args.direction === SwapDirection.SyToPt) {
+        // Cross to create a new interval
+        const predecessor = getPredecessorTickKey(ticks, currentLeftBoundaryIndex)
+        if (predecessor === null) break
+
+        // Update active liquidity by subtracting liquidity_net at boundary
+        const boundaryTick = findTickByKey(ticks, predecessor)
+
+        // When crossing downward (SyToPt), update state
+        currentPriceSpot = getImpliedRate(currentLeftBoundaryIndex) // Boundary we're crossing
+        currentLeftBoundaryIndex = boundaryTick.index // New left boundary
+
+        if (boundaryTick) {
+          activeLiquidityU64 = bigIntMax(0n, activeLiquidityU64 - boundaryTick.tick.liquidityNet)
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+        continue
+      } else {
+        // No more liquidity available
+        break
+      }
+    }
+
+    const rightBoundaryIndex: number = rightBoundaryIndexOpt ?? 0
+
+    // Get anchor prices for interval boundaries
+    const anchorULeft: number = getImpliedRate(findTickByIndex(ticks, currentLeftBoundaryIndex)?.apyBasePoints ?? 0)
+    const anchorURight: number = getImpliedRate(findTickByIndex(ticks, rightBoundaryIndex)?.apyBasePoints ?? 0)
+
+    // Effective price at current spot
+    const cEffOld: number = snapshot.getEffectivePrice(currentPriceSpot)
+
+    // Get principal ledgers for the interval
+    const currentTickData = findTickByIndex(ticks, currentLeftBoundaryIndex)
+
+    const principalPt: bigint = currentTickData?.principalPt ?? 0n
+    const principalSy: bigint = currentTickData?.principalSy ?? 0n
+
+    const eps: number = configurationOptions.epsilonClamp
+
+    // Calculate kappa (scaling factor based on available principal)
+    // Y_max = (L/τ) * (C(u_old) - C(u_right))
+    const cEffAtBoundary: number = snapshot.getEffectivePrice(anchorURight)
+    const yMaxToBoundaryF: number = activeLiquidityF64 * (cEffOld - cEffAtBoundary)
+    const kappaSy: number = yMaxToBoundaryF > 0 ? Number(principalSy) / yMaxToBoundaryF : 0
+
+    const duToLeft: number = currentPriceSpot - anchorULeft
+    const ptMaxToLeftF: number = activeLiquidityF64 * duToLeft
+    const kappaPt: number = ptMaxToLeftF > 0 ? Number(principalPt) / ptMaxToLeftF : 0
+
+    const kappa = Math.min(kappaPt, kappaSy)
+
+    // Boundary ΔC if we go to u_right
+    const lTradeF64: number = activeLiquidityF64 * kappa
+
+    if (args.direction === SwapDirection.PtToSy) {
+      // PT -> SY swap (buying SY with PT)
+      const duByInput: number = lTradeF64 > 0 ? amountInLeft / lTradeF64 : 0
+      const duToBoundary: number = anchorURight - currentPriceSpot
+      const duActual: number = Math.min(duByInput, duToBoundary)
+
+      if (duToBoundary <= eps) {
+        // Cross boundary
+        const boundaryTick = findTickByIndex(ticks, rightBoundaryIndex)
+        if (boundaryTick) {
+          activeLiquidityU64 += boundaryTick.liquidityNet
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+        currentLeftBoundaryIndex = rightBoundaryIndex
+        currentPriceSpot = anchorURight
+        continue
+      }
+
+      // Token flows for this segment
+      const ptInSegment: number = Math.floor(lTradeF64 * duActual)
+      const anchorUNew: number = currentPriceSpot + duActual
+      const cEffNew: number = snapshot.getEffectivePrice(anchorUNew)
+      const syOutGross: number = Math.floor(lTradeF64 * (cEffOld - cEffNew))
+      const syOutGrossClamped: number = Math.min(syOutGross, Number(principalSy))
+
+      if (syOutGrossClamped > 0) {
+        const totalFeeOut: number = getFeeFromAmount(syOutGrossClamped, lpFeeRate)
+        const protocolFeeOut: number = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
+        const lpFeeOut: number = totalFeeOut - protocolFeeOut
+        const syOutNet: number = syOutGrossClamped - totalFeeOut
+
+        amountOutNet += syOutNet
+        feeLpOut += lpFeeOut
+        feeProtocolOut += protocolFeeOut
+      }
+
+      amountInLeft -= ptInSegment
+      currentPriceSpot = anchorUNew
+
+      // If we hit boundary, cross
+      if (Math.abs(anchorURight - currentPriceSpot) <= eps && amountInLeft > 0) {
+        const boundaryTick = findTickByIndex(ticks, rightBoundaryIndex)
+        if (boundaryTick) {
+          activeLiquidityU64 += boundaryTick.liquidityNet
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+        currentLeftBoundaryIndex = rightBoundaryIndex
+        currentPriceSpot = anchorURight
+      }
+    } else {
+      // SY -> PT swap (buying PT with SY)
+      const cEffLeft: number = snapshot.getEffectivePrice(anchorULeft)
+      const deltaCByInput: number = lTradeF64 > 0 ? amountInLeft / lTradeF64 : 0
+      const deltaCToLeftBoundary: number = Math.max(0, cEffLeft - cEffOld)
+      const deltaCActual: number = Math.min(deltaCByInput, deltaCToLeftBoundary)
+
+      if (debug) {
+        console.log(`SyToPt deltas: byInput=${deltaCByInput}, toBoundary=${deltaCToLeftBoundary}`)
+        console.log(`  deltaCActual=${deltaCActual}, eps=${eps}, kappa=${kappa}, lTrade=${lTradeF64}`)
+      }
+
+      if (deltaCToLeftBoundary <= eps) {
+        // Cross boundary to the left
+        const predecessor = getPredecessorTickKey(ticks, currentLeftBoundaryIndex)
+        if (predecessor === null) break
+
+        // Update active liquidity by subtracting liquidity_net at boundary
+        const boundaryTick = findTickByIndex(ticks, currentLeftBoundaryIndex)
+        if (boundaryTick) {
+          activeLiquidityU64 = bigIntMax(0n, activeLiquidityU64 - boundaryTick.liquidityNet)
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+
+        currentPriceSpot = getImpliedRate(currentLeftBoundaryIndex)
+        currentLeftBoundaryIndex = predecessor
+        continue
+      }
+
+      // New effective price and spot price after consuming ΔC
+      const cEffNew: number = cEffOld + deltaCActual
+      const spotPriceNew: number = snapshot.spotPriceFromEffectivePrice(cEffNew)
+
+      // Token flows
+      const syInSegmentF: number = lTradeF64 * (cEffNew - cEffOld)
+      const duAbs: number = currentPriceSpot - spotPriceNew
+      const ptOutGrossF: number = lTradeF64 * duAbs
+
+      // Clamp gross PT by available principal
+      const ptOutGrossU64: bigint = bigIntMin(BigInt(Math.floor(ptOutGrossF)), principalPt)
+      const syInSegmentU64: bigint = BigInt(Math.floor(syInSegmentF))
+
+      if (debug) {
+        console.log(`SyToPt: deltaCActual=${deltaCActual}, cEffNew=${cEffNew}, spotPriceNew=${spotPriceNew}`)
+        console.log(`  duAbs=${duAbs}, ptOutGrossF=${ptOutGrossF}, ptOutGrossU64=${ptOutGrossU64}`)
+        console.log(`  syInSegmentU64=${syInSegmentU64}, principalPt=${principalPt}`)
+      }
+
+      if (ptOutGrossU64 === 0n) {
+        // Nothing to pay out; try to cross
+        const predecessor = getPredecessorTickKey(ticks, currentLeftBoundaryIndex)
+        if (predecessor === null) break
+
+        // Update active liquidity
+        const boundaryTick = findTickByIndex(ticks, currentLeftBoundaryIndex)
+        if (boundaryTick) {
+          activeLiquidityU64 = bigIntMax(0n, activeLiquidityU64 - boundaryTick.liquidityNet)
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+
+        currentPriceSpot = getImpliedRate(currentLeftBoundaryIndex)
+        currentLeftBoundaryIndex = predecessor
+        continue
+      }
+
+      // Fees in token_out (PT)
+      const totalFeeOut: number = getFeeFromAmount(Number(ptOutGrossU64), lpFeeRate)
+      const protocolFeeOut: number = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
+      const lpFeeOut: number = totalFeeOut - protocolFeeOut
+      const ptOutNet: number = Number(ptOutGrossU64) - totalFeeOut
+
+      // Accumulate to user
+      amountOutNet += ptOutNet
+      feeLpOut += lpFeeOut
+      feeProtocolOut += protocolFeeOut
+
+      // Consume input and advance state
+      amountInLeft -= Number(syInSegmentU64)
+      currentPriceSpot = spotPriceNew
+
+      // If we hit boundary, cross
+      if (Math.abs(currentPriceSpot - anchorULeft) <= eps && amountInLeft > 0) {
+        const predecessor = getPredecessorTickKey(ticks, currentLeftBoundaryIndex)
+        if (predecessor === null) break
+
+        // Update active liquidity
+        const boundaryTick = findTickByIndex(ticks, currentLeftBoundaryIndex)
+        if (boundaryTick) {
+          activeLiquidityU64 = bigIntMax(0n, activeLiquidityU64 - boundaryTick.liquidityNet)
+          activeLiquidityF64 = Number(activeLiquidityU64)
+        }
+
+        currentPriceSpot = getImpliedRate(currentLeftBoundaryIndex)
+        currentLeftBoundaryIndex = predecessor
+      }
+    }
+  }
+
+  return {
+    amountInConsumed: args.amountIn - amountInLeft,
+    amountOut: amountOutNet,
+    lpFeeChargedOutToken: feeLpOut,
+    protocolFeeChargedOutToken: feeProtocolOut,
+    finalSpotPrice: currentPriceSpot,
+    finalTickIndex: currentLeftBoundaryIndex,
+  }
+}