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

package/src/ytTradesLegacy.ts

@@ -0,0 +1,419 @@
+/**
+ * YT (Yield Token) trade simulations
+ *
+ * YT trades are multi-step operations that involve PT trades:
+ * - Buy YT: Strip SY → PT+YT, then sell PT back to pool
+ * - Sell YT: Merge PT+YT → SY, then buy PT from pool to repay
+ */
+import { bisectSearch2 } from "./bisect"
+import { simulateSwap } from "./swapV2"
+import { MarketThreeState, SwapDirection } from "./types"
+
+/**
+ * Helper function to convert PY to SY
+ * @param syExchangeRate - The SY exchange rate
+ * @param pyAmount - The PY (PT or YT) amount
+ * @returns The equivalent SY amount
+ */
+function pyToSy(syExchangeRate: number, pyAmount: number): number {
+  if (syExchangeRate <= 0) return 0
+  return Math.floor(pyAmount / syExchangeRate)
+}
+
+/**
+ * Helper function to convert SY to PY
+ * @param syExchangeRate - The SY exchange rate
+ * @param syAmount - The SY amount
+ * @returns The equivalent PY amount
+ */
+function syToPy(syExchangeRate: number, syAmount: number): number {
+  return Math.floor(syAmount * syExchangeRate)
+}
+
+export interface BuyYtSimulationArgs {
+  /** Amount of YT desired to buy */
+  ytOut: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+export interface BuyYtSimulationResult {
+  /** Amount of YT received */
+  ytOut: number
+  /** Net SY cost to the trader */
+  netSyCost: number
+  /** Amount of SY that needs to be stripped */
+  syToStrip: number
+  /** Amount of PT received from stripping */
+  ptFromStrip: number
+  /** Amount of SY received from selling PT */
+  syFromPtSale: number
+  /** LP fee charged */
+  lpFee: number
+  /** Protocol fee charged */
+  protocolFee: number
+  /** Final spot price after the trade */
+  finalSpotPrice: number
+}
+
+/**
+ * Simulates buying YT tokens
+ *
+ * Process:
+ * 1. Calculate how much SY to strip to get desired YT
+ * 2. Strip SY → PT + YT (PT amount ≈ YT amount)
+ * 3. Sell PT to the pool (PtToSy direction)
+ * 4. Net cost = SY stripped - SY received from PT sale
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with net SY cost
+ */
+export function simulateBuyYt(marketState: MarketThreeState, args: BuyYtSimulationArgs): BuyYtSimulationResult {
+  const { ytOut, syExchangeRate, priceSpotLimit } = args
+
+  // Calculate how much SY needs to be stripped to get the desired YT
+  // Add 1 to counter-act the flooring function when converting from PY to SY
+  const syToStrip = pyToSy(syExchangeRate, ytOut) + 1
+
+  // Stripping gives approximately equal amounts of PT and YT
+  const ptFromStrip = ytOut
+
+  // Simulate selling the PT to get SY back
+  // Note: We use ytOut as the amount because PT out = YT out from the strip
+  const swapResult = simulateSwap(marketState, {
+    direction: SwapDirection.PtToSy,
+    amountIn: ytOut,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  const syFromPtSale = swapResult.amountOut
+
+  // Net cost is the difference between what was stripped and what was received
+  const netSyCost = syToStrip - syFromPtSale
+
+  return {
+    ytOut,
+    netSyCost,
+    syToStrip,
+    ptFromStrip,
+    syFromPtSale,
+    lpFee: swapResult.lpFeeChargedOutToken,
+    protocolFee: swapResult.protocolFeeChargedOutToken,
+    finalSpotPrice: swapResult.finalSpotPrice,
+  }
+}
+
+export interface BuyYtWithSyInSimulationArgs {
+  /** Amount of SY to spend */
+  syIn: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+/**
+ * Simulates buying YT tokens given a SY input amount
+ *
+ * Process:
+ * 1. Strip syIn → PT + YT
+ * 2. Sell PT → get SY back (with price impact)
+ * 3. Strip SY again → more PT + YT
+ * 4. Repeat until convergence
+ * Total YT = YT₁ + YT₂ + YT₃ + ...
+ *
+ * Uses bisection search to find ytOut such that netSyCost = syIn
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with calculated YT output
+ */
+export function simulateBuyYtWithSyIn(
+  marketState: MarketThreeState,
+  args: BuyYtWithSyInSimulationArgs,
+): BuyYtSimulationResult {
+  const { syIn, syExchangeRate, priceSpotLimit } = args
+
+  // Lower bound: Start very low since PT recycling allows buying much more YT than naive calculation
+  // The actual minimum depends on PT price (how much SY we get back from selling PT)
+  // If PT price is high (close to 1), we get most SY back, so we can buy much more YT
+  // Example: With 1000 SY and PT price 0.9:
+  //   - To get 5000 YT, strip 5000 SY → 5000 PT + 5000 YT
+  //   - Sell 5000 PT at 0.9 → 4500 SY back
+  //   - Net cost: 5000 - 4500 = 500 SY (way less than 1000!)
+  const minPossibleYt = 1
+
+  // Better initial upper bound estimate based on market liquidity
+  // Maximum possible YT is constrained by available PT liquidity in the market
+  const marketPtLiquidity = Number(marketState.financials.ptBalance)
+  const marketSyLiquidity = Number(marketState.financials.syBalance)
+
+  // Conservative estimate: we can't buy more YT than there's PT in the market
+  // High multiplier needed because PT recycling amplifies buying power dramatically
+  // Formula: ytOut ≈ syIn / (1 - ptPrice)
+  // Examples: PT@0.99 → 100x, PT@0.95 → 20x, PT@0.90 → 10x, PT@0.80 → 5x
+  const liquidityBasedMax = Math.min(
+    marketPtLiquidity * 0.9, // 90% of PT liquidity to be safe
+    syToPy(syExchangeRate, syIn) * 100, // 100x to handle PT prices up to 0.99
+  )
+
+  // Start with a reasonable initial guess (10x covers most realistic scenarios)
+  let maxPossibleYt = Math.min(syToPy(syExchangeRate, syIn) * 10, liquidityBasedMax)
+  let foundUpperBound = false
+  let lastValidCost = 0
+
+  // Use exponential search with better growth rate
+  for (let attempt = 0; attempt < 12; attempt++) {
+    try {
+      const syToStrip = pyToSy(syExchangeRate, maxPossibleYt) + 1
+
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.PtToSy,
+        amountIn: maxPossibleYt,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      const syFromPtSale = swapResult.amountOut
+      const netSyCost = syToStrip - syFromPtSale
+
+      // If this costs more than syIn, we found our upper bound
+      if (netSyCost > syIn) {
+        foundUpperBound = true
+        break
+      }
+
+      lastValidCost = netSyCost
+
+      // Use adaptive growth rate based on how far we are from target
+      const costRatio = syIn / Math.max(netSyCost, 1)
+      const growthFactor = attempt < 3 ? 2.0 : Math.min(1.5, 1 + costRatio * 0.3)
+
+      maxPossibleYt *= growthFactor
+
+      // Don't exceed liquidity constraints
+      if (maxPossibleYt > liquidityBasedMax) {
+        maxPossibleYt = liquidityBasedMax
+        foundUpperBound = true
+        break
+      }
+    } catch (error) {
+      // If simulation fails, we've exceeded market capacity
+      // Use last valid value with small buffer, ensuring it's > minPossibleYt
+      if (lastValidCost > 0) {
+        // Interpolate to find better upper bound
+        const estimatedMax = maxPossibleYt * 0.7 * (syIn / lastValidCost)
+        maxPossibleYt = Math.max(estimatedMax, minPossibleYt * 1.2)
+      } else {
+        // No valid cost yet, use a conservative upper bound
+        maxPossibleYt = Math.max(maxPossibleYt * 0.8, minPossibleYt * 1.5)
+      }
+      foundUpperBound = true
+      break
+    }
+  }
+
+  if (!foundUpperBound) {
+    throw new Error(`Could not find upper bound for YT amount. Market may have unusual price dynamics.`)
+  }
+
+  // Final safety check: ensure maxPossibleYt > minPossibleYt
+  if (maxPossibleYt <= minPossibleYt) {
+    maxPossibleYt = minPossibleYt * 2
+  }
+
+  // Use bisection search to find the ytOut that results in netSyCost = syIn
+  // Adaptive epsilon based on input size for better precision scaling
+  const adaptiveEpsilon = Math.max(0.01, syIn * 0.0001)
+
+  // Reduce max iterations since we have better bounds
+  const maxIterations = 10000
+
+  // Debug info for bounds validation
+  if (maxPossibleYt <= minPossibleYt) {
+    throw new Error(
+      `Invalid bisection bounds for buy YT. ` +
+        `Min: ${minPossibleYt}, Max: ${maxPossibleYt}, ` +
+        `SyIn: ${syIn}, SyExchangeRate: ${syExchangeRate}, ` +
+        `MarketPtBalance: ${marketPtLiquidity}, MarketSyBalance: ${marketSyLiquidity}`,
+    )
+  }
+
+  const ytOut = bisectSearch2(
+    (ytGuess: number) => {
+      // Calculate the cost for this ytGuess
+      const syToStrip = pyToSy(syExchangeRate, ytGuess) + 1
+
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.PtToSy,
+        amountIn: ytGuess,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      const syFromPtSale = swapResult.amountOut
+      const netSyCost = syToStrip - syFromPtSale
+
+      // Return the difference between actual cost and target syIn
+      return netSyCost - syIn
+    },
+    minPossibleYt,
+    maxPossibleYt,
+    adaptiveEpsilon,
+    maxIterations,
+  )
+
+  if (ytOut === null) {
+    throw new Error(
+      `Failed to converge on correct YT amount. ` +
+        `Search range: [${minPossibleYt}, ${maxPossibleYt}], ` +
+        `Epsilon: ${adaptiveEpsilon}`,
+    )
+  }
+
+  // Now calculate the full result with the found ytOut
+  return simulateBuyYt(marketState, {
+    ytOut,
+    syExchangeRate,
+    priceSpotLimit,
+  })
+}
+
+export interface SellYtSimulationArgs {
+  /** Amount of YT to sell */
+  ytIn: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+export interface SellYtSimulationResult {
+  /** Amount of YT sold */
+  ytIn: number
+  /** Net SY received by the trader */
+  netSyReceived: number
+  /** Amount of SY received from merging PT + YT */
+  syFromMerge: number
+  /** Amount of SY spent buying PT back */
+  sySpentOnPt: number
+  /** LP fee charged */
+  lpFee: number
+  /** Protocol fee charged */
+  protocolFee: number
+  /** Final spot price after the trade */
+  finalSpotPrice: number
+}
+
+/**
+ * Simulates selling YT tokens
+ *
+ * Process:
+ * 1. Merge PT + YT → SY (receive SY from the merge)
+ * 2. Buy PT from the pool to repay the borrowed PT (SyToPt direction)
+ * 3. Net received = SY from merge - SY spent on PT
+ *
+ * Note: The market must have at least 2x the YT amount in PT liquidity
+ * because the trader borrows PT, which is then bought back.
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with net SY received
+ */
+export function simulateSellYt(marketState: MarketThreeState, args: SellYtSimulationArgs): SellYtSimulationResult {
+  const { ytIn, syExchangeRate, priceSpotLimit } = args
+
+  // Check if there's sufficient PT liquidity
+  // The market needs at least 2x the YT amount in PT
+  if (marketState.financials.ptBalance < ytIn * 2) {
+    throw new Error(
+      `Insufficient PT liquidity in the market. Required: ${ytIn * 2}, Available: ${marketState.financials.ptBalance}`,
+    )
+  }
+
+  // Merging PT + YT gives back the original SY
+  // The amount of PT needed equals ytIn (1:1 ratio)
+  const syFromMerge = pyToSy(syExchangeRate, ytIn)
+
+  const ptNeeded = ytIn
+
+  const upperBoundSwap = simulateSwap(marketState, {
+    direction: SwapDirection.SyToPt,
+    amountIn: syFromMerge,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  // Check that we can buy enough PT from CLMM
+  if (upperBoundSwap.amountOut < ptNeeded) {
+    throw new Error(
+      `Cannot buy enough PT with available SY. Need ${ytIn} PT but can only afford ${upperBoundSwap.amountOut} PT`,
+    )
+  }
+
+  // Better initial bounds for bisection
+  // We know the upper bound from the check above, and we can estimate a better lower bound
+  // based on the current price
+  const estimatedLowerBound = Math.min(syFromMerge * 0.5, syFromMerge * 0.9) // Start from 50% of max, but not too close to upper
+
+  // Adaptive epsilon based on PT needed
+  const adaptiveEpsilon = Math.max(0.01, ptNeeded * 0.0001)
+
+  // Safety check: ensure lower bound is less than upper bound
+  const safeLowerBound = Math.min(estimatedLowerBound, syFromMerge * 0.95)
+  const safeUpperBound = syFromMerge
+
+  if (safeLowerBound >= safeUpperBound) {
+    throw new Error(`Invalid bisection bounds for sell YT. Lower: ${safeLowerBound}, Upper: ${safeUpperBound}`)
+  }
+
+  const syToSpend = bisectSearch2(
+    (syGuess: number) => {
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.SyToPt,
+        amountIn: syGuess,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      return swapResult.amountOut - ptNeeded
+    },
+    safeLowerBound,
+    safeUpperBound,
+    adaptiveEpsilon,
+    100, // Reduced iterations with better bounds
+  )
+
+  if (syToSpend === null) {
+    throw new Error("Failed to converge on correct SY amount using bisection search")
+  }
+
+  const swapResult = simulateSwap(marketState, {
+    direction: SwapDirection.SyToPt,
+    amountIn: syToSpend,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  const netSyReceived = syFromMerge - swapResult.amountInConsumed
+
+  return {
+    ytIn,
+    netSyReceived,
+    syFromMerge,
+    sySpentOnPt: swapResult.amountInConsumed,
+    lpFee: swapResult.lpFeeChargedOutToken,
+    protocolFee: swapResult.protocolFeeChargedOutToken,
+    finalSpotPrice: swapResult.finalSpotPrice,
+  }
+}

package/build/swap-v2.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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";
-/**
- * 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 declare function simulateSwap(marketState: MarketThreeState, args: SwapArgs): SwapOutcome;
-/**
- * Calculate the expected output for a given input amount
- * This is a convenience wrapper around simulateSwap
- */
-export declare function getSwapQuote(marketState: MarketThreeState, amountIn: number, direction: SwapDirection): SwapOutcome;

package/build/swap-v2.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwapQuote = exports.simulateSwap = void 0;
-/**
- * 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)
- */
-const types_1 = require("./types");
-const utils_1 = require("./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
- */
-function simulateSwap(marketState, args) {
-    const { financials, configurationOptions, ticks } = marketState;
-    const secondsRemaining = Math.max(0, financials.expirationTs - Date.now() / 1000);
-    // Create effective price snapshot
-    const snapshot = new utils_1.EffSnap((0, utils_1.normalizedTimeRemaining)(secondsRemaining), args.syExchangeRate);
-    // Current state
-    let currentPriceSpot = ticks.currentSpotPrice;
-    let currentLeftBoundaryIndex = ticks.currentTick;
-    // Use currentPrefixSum if available, otherwise fall back to calculating it
-    let activeLiquidityU64 = ticks.currentPrefixSum ?? 0;
-    let activeLiquidityF64 = activeLiquidityU64;
-    // Fees
-    const lpFeeRate = (0, utils_1.calculateFeeRate)(configurationOptions.lnFeeRateRoot, secondsRemaining);
-    const protocolFeeBps = configurationOptions.treasuryFeeBps;
-    // Check price limits
-    if (args.priceSpotLimit !== undefined) {
-        if (args.direction === types_1.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 = 0;
-    let feeLpOut = 0;
-    let feeProtocolOut = 0;
-    let amountInLeft = args.amountIn;
-    // Main loop across contiguous intervals
-    let iterations = 0;
-    const maxIterations = 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 < maxIterations) {
-        iterations++;
-        if (debug)
-            console.log(`\n--- Iteration ${iterations}, amountInLeft=${amountInLeft} ---`);
-        // Get right boundary of current interval
-        const rightBoundaryIndexOpt = (0, utils_1.getSuccessorTick)(ticks, currentLeftBoundaryIndex);
-        if (debug)
-            console.log(`rightBoundary=${rightBoundaryIndexOpt}`);
-        if (rightBoundaryIndexOpt === null) {
-            if (args.direction === types_1.SwapDirection.SyToPt) {
-                // Cross to create a new interval
-                const predecessor = (0, utils_1.getPredecessorTick)(ticks, currentLeftBoundaryIndex);
-                if (predecessor === null)
-                    break;
-                // When crossing downward (SyToPt), update state
-                currentPriceSpot = (0, utils_1.getLnImpliedRate)(currentLeftBoundaryIndex); // Boundary we're crossing
-                currentLeftBoundaryIndex = predecessor; // New left boundary
-                // Update active liquidity by subtracting liquidity_net at boundary
-                const boundaryTick = (0, utils_1.findTick)(ticks, predecessor);
-                if (boundaryTick) {
-                    activeLiquidityU64 = Math.max(0, activeLiquidityU64 - boundaryTick.tick.liquidityNet);
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                continue;
-            }
-            else {
-                // No more liquidity available
-                break;
-            }
-        }
-        const rightBoundaryIndex = rightBoundaryIndexOpt;
-        // Get anchor prices for interval boundaries
-        const anchorULeft = (0, utils_1.getLnImpliedRate)(currentLeftBoundaryIndex);
-        const anchorURight = (0, utils_1.getLnImpliedRate)(rightBoundaryIndex);
-        // Effective price at current spot
-        const cEffOld = snapshot.getEffectivePrice(currentPriceSpot);
-        // Get principal ledgers for the interval
-        const currentTickData = (0, utils_1.findTick)(ticks, currentLeftBoundaryIndex);
-        const principalPt = currentTickData?.tick.principalPt ?? 0;
-        const principalSy = currentTickData?.tick.principalSy ?? 0;
-        const eps = configurationOptions.epsilonClamp;
-        // Calculate kappa (scaling factor based on available principal)
-        // Y_max = (L/τ) * (C(u_old) - C(u_right))
-        const cEffAtBoundary = snapshot.getEffectivePrice(anchorURight);
-        const yMaxToBoundaryF = (activeLiquidityF64 / snapshot.timeFactor) * (cEffOld - cEffAtBoundary);
-        const kappaSy = yMaxToBoundaryF > 0 ? principalSy / yMaxToBoundaryF : 0;
-        const duToLeft = currentPriceSpot - anchorULeft;
-        const ptMaxToLeftF = activeLiquidityF64 * duToLeft;
-        const kappaPt = ptMaxToLeftF > 0 ? principalPt / ptMaxToLeftF : 0;
-        const kappa = Math.min(kappaPt, kappaSy, 1.0);
-        const lTradeF64 = activeLiquidityF64 * kappa;
-        if (args.direction === types_1.SwapDirection.PtToSy) {
-            // PT -> SY swap (buying SY with PT)
-            const duByInput = lTradeF64 > 0 ? amountInLeft / lTradeF64 : 0;
-            const duToBoundary = anchorURight - currentPriceSpot;
-            const duActual = Math.min(duByInput, duToBoundary);
-            if (duToBoundary <= eps) {
-                // Cross boundary
-                const boundaryTick = (0, utils_1.findTick)(ticks, rightBoundaryIndex);
-                if (boundaryTick) {
-                    activeLiquidityU64 += boundaryTick.tick.liquidityNet;
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                currentLeftBoundaryIndex = rightBoundaryIndex;
-                currentPriceSpot = anchorURight;
-                continue;
-            }
-            // Token flows for this segment
-            const ptInSegment = Math.floor(lTradeF64 * duActual);
-            const anchorUNew = currentPriceSpot + duActual;
-            const cEffNew = snapshot.getEffectivePrice(anchorUNew);
-            const syOutGross = Math.floor((lTradeF64 / snapshot.timeFactor) * (cEffOld - cEffNew));
-            const syOutGrossClamped = Math.min(syOutGross, principalSy);
-            if (syOutGrossClamped > 0) {
-                const totalFeeOut = (0, utils_1.getFeeFromAmount)(syOutGrossClamped, lpFeeRate);
-                const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS);
-                const lpFeeOut = totalFeeOut - protocolFeeOut;
-                const syOutNet = 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 = (0, utils_1.findTick)(ticks, rightBoundaryIndex);
-                if (boundaryTick) {
-                    activeLiquidityU64 += boundaryTick.tick.liquidityNet;
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                currentLeftBoundaryIndex = rightBoundaryIndex;
-                currentPriceSpot = anchorURight;
-            }
-        }
-        else {
-            // SY -> PT swap (buying PT with SY)
-            const cEffLeft = snapshot.getEffectivePrice(anchorULeft);
-            const deltaCByInput = lTradeF64 > 0 ? (snapshot.timeFactor / lTradeF64) * amountInLeft : 0;
-            const deltaCToLeftBoundary = Math.max(0, cEffLeft - cEffOld);
-            const deltaCActual = 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 = (0, utils_1.getPredecessorTick)(ticks, currentLeftBoundaryIndex);
-                if (predecessor === null)
-                    break;
-                // Update active liquidity by subtracting liquidity_net at boundary
-                const boundaryTick = (0, utils_1.findTick)(ticks, currentLeftBoundaryIndex);
-                if (boundaryTick) {
-                    activeLiquidityU64 = Math.max(0, activeLiquidityU64 - boundaryTick.tick.liquidityNet);
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                currentPriceSpot = (0, utils_1.getLnImpliedRate)(currentLeftBoundaryIndex);
-                currentLeftBoundaryIndex = predecessor;
-                continue;
-            }
-            // New effective price and spot price after consuming ΔC
-            const cEffNew = cEffOld + deltaCActual;
-            const spotPriceNew = snapshot.spotPriceFromEffectivePrice(cEffNew);
-            // Token flows
-            const syInSegmentF = (lTradeF64 / snapshot.timeFactor) * (cEffNew - cEffOld);
-            const duAbs = currentPriceSpot - spotPriceNew;
-            const ptOutGrossF = lTradeF64 * duAbs;
-            // Clamp gross PT by available principal
-            const ptOutGrossU64 = Math.min(Math.floor(ptOutGrossF), principalPt);
-            const syInSegmentU64 = 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 === 0) {
-                // Nothing to pay out; try to cross
-                const predecessor = (0, utils_1.getPredecessorTick)(ticks, currentLeftBoundaryIndex);
-                if (predecessor === null)
-                    break;
-                // Update active liquidity
-                const boundaryTick = (0, utils_1.findTick)(ticks, currentLeftBoundaryIndex);
-                if (boundaryTick) {
-                    activeLiquidityU64 = Math.max(0, activeLiquidityU64 - boundaryTick.tick.liquidityNet);
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                currentPriceSpot = (0, utils_1.getLnImpliedRate)(currentLeftBoundaryIndex);
-                currentLeftBoundaryIndex = predecessor;
-                continue;
-            }
-            // Fees in token_out (PT)
-            const totalFeeOut = (0, utils_1.getFeeFromAmount)(ptOutGrossU64, lpFeeRate);
-            const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS);
-            const lpFeeOut = totalFeeOut - protocolFeeOut;
-            const ptOutNet = ptOutGrossU64 - totalFeeOut;
-            // Accumulate to user
-            amountOutNet += ptOutNet;
-            feeLpOut += lpFeeOut;
-            feeProtocolOut += protocolFeeOut;
-            // Consume input and advance state
-            amountInLeft -= syInSegmentU64;
-            currentPriceSpot = spotPriceNew;
-            // If we hit boundary, cross
-            if (Math.abs(currentPriceSpot - anchorULeft) <= eps && amountInLeft > 0) {
-                const predecessor = (0, utils_1.getPredecessorTick)(ticks, currentLeftBoundaryIndex);
-                if (predecessor === null)
-                    break;
-                // Update active liquidity
-                const boundaryTick = (0, utils_1.findTick)(ticks, currentLeftBoundaryIndex);
-                if (boundaryTick) {
-                    activeLiquidityU64 = Math.max(0, activeLiquidityU64 - boundaryTick.tick.liquidityNet);
-                    activeLiquidityF64 = activeLiquidityU64;
-                }
-                currentPriceSpot = (0, utils_1.getLnImpliedRate)(currentLeftBoundaryIndex);
-                currentLeftBoundaryIndex = predecessor;
-            }
-        }
-    }
-    return {
-        amountInConsumed: args.amountIn - amountInLeft,
-        amountOut: amountOutNet,
-        lpFeeChargedOutToken: feeLpOut,
-        protocolFeeChargedOutToken: feeProtocolOut,
-        finalSpotPrice: currentPriceSpot,
-        finalTickIndex: currentLeftBoundaryIndex,
-    };
-}
-exports.simulateSwap = simulateSwap;
-/**
- * Calculate the expected output for a given input amount
- * This is a convenience wrapper around simulateSwap
- */
-function getSwapQuote(marketState, amountIn, direction) {
-    return simulateSwap(marketState, {
-        direction,
-        amountIn,
-        syExchangeRate: marketState.currentSyExchangeRate,
-        isCurrentFlashSwap: false,
-    });
-}
-exports.getSwapQuote = getSwapQuote;
-//# sourceMappingURL=swap-v2.js.map