@exponent-labs/market-three-math 0.9.12 → 0.9.13

package/src/addLiquidity.ts

@@ -2,6 +2,8 @@
  * CLMM Add Liquidity simulation
  * Ported from exponent_clmm/src/state/market_three/helpers/add_liquidity.rs
  */
+import { Ticks } from "@exponent-labs/exponent-fetcher"
+
 import { simulateSwap, simulateSwapExactOut } from "./swapV2"
 import {
   AddLiquidityArgs,
@@ -12,15 +14,22 @@ import {
   MarketThreeState,
   SwapDirection,
 } from "./types"
-import { EffSnap, normalizedTimeRemaining, TicksWrapper } from "./utilsV2"
 import { findTickByKey, getSuccessorTickKey } from "./utils"
-import { Ticks } from "@exponent-labs/exponent-fetcher"
+import { EffSnap, TicksWrapper, normalizedTimeRemaining } from "./utilsV2"
 
 const TICK_KEY_BASE_POINTS = 1_000_000
 // Keep this in sync with exponent_clmm's add_liquidity helper so off-chain
 // quotes match the on-chain classic deposit path as closely as possible.
-const GAP_TOKEN_NEEDS = 5
-const SWAP_EXACT_OUT_SY_HEADROOM = 10
+const GAP_TOKEN_NEEDS = 20
+const MIN_SWAP_EXACT_OUT_SY_HEADROOM = 100
+const SWAP_EXACT_OUT_SY_HEADROOM = 100
+const SWAP_EXACT_OUT_HEADROOM_PT_THRESHOLD = 10_000_000
+const MIN_SWAP_AND_SUPPLY_SY_BUDGET = 1_000_000
+const FLASH_SY_POSITION_HEADROOM = 1_000
+const MAX_SWAP_AND_SUPPLY_UNDERSPEND_LAMPORTS = 1_000
+const MAX_SWAP_AND_SUPPLY_SIMULATED_OVERSPEND_LAMPORTS = 0
+const LARGE_SWAP_AND_SUPPLY_SY_BUDGET = 50_000_000_000
+const PT_ONLY_SWAP_EXACT_OUT_ESTIMATE_SLACK = 0
 
 const EMPTY_CROSSING_TICK_STATE: CrossingTickState = {
   principalPt: 0,
@@ -416,12 +425,12 @@ function simulateAccruePrincipalForDeposit(params: {
     return predecessor ?? candidateKey
   }
 
-  const visitIntervals = (startKey: number, priceStart: number, priceEnd: number, visitor: (params: {
-    leftKey: number
-    rightKey: number
-    leftPrice: number
-    rightPrice: number
-  }) => void) => {
+  const visitIntervals = (
+    startKey: number,
+    priceStart: number,
+    priceEnd: number,
+    visitor: (params: { leftKey: number; rightKey: number; leftPrice: number; rightPrice: number }) => void,
+  ) => {
     if (!(priceStart < priceEnd)) {
       return
     }
@@ -953,8 +962,7 @@ export function simulateWrapperProvideLiquidity(
     const priceEffUpper = snap.getEffectivePrice(upperPrice)
 
     // Step 3: Get crossing tick state (matches wrapper_provide_liquidity.rs)
-    const { crossingTickState, crossingTickPriceLeft, crossingTickPriceRight } =
-      getCrossingTickStateFromTicks(ticks)
+    const { crossingTickState, crossingTickPriceLeft, crossingTickPriceRight } = getCrossingTickStateFromTicks(ticks)
 
     // Step 4: Calculate mock token needs using compute_token_needs_with_crossing
     // max_sy = syAmount, max_pt = syAmount * syExchangeRate (as on-chain)
@@ -997,6 +1005,10 @@ export function simulateWrapperProvideLiquidity(
       syExchangeRate,
     })
 
+    if (!hasLpSupplyCapacity(marketState, depositResult.deltaL)) {
+      return null
+    }
+
     return {
       lpOut: depositResult.deltaL,
       ytOut: Math.floor(ytOut),
@@ -1047,9 +1059,9 @@ export function simulateSwapAndSupply(
     // Wrapper provide-liquidity-base debits base as:
     //   base_needed = ceil(total_sy_spent * sy_exchange_rate)
     // So the strict SY budget for a user-provided base input is floor(base / rate).
-    const syBudget = convertBaseToSyBudget(amountBase)
+    const syBudget = convertBaseToSyBudget(amountBase, syExchangeRate)
 
-    if (syBudget <= 0) {
+    if (syBudget <= 0 || syBudget < MIN_SWAP_AND_SUPPLY_SY_BUDGET) {
       return {
         lpOut: 0,
         ptToBuy: 0,
@@ -1062,6 +1074,11 @@ export function simulateSwapAndSupply(
       }
     }
 
+    const flashSyAvailable = Math.max(0, Number(marketState.financials.syBalance) - FLASH_SY_POSITION_HEADROOM)
+    if (syBudget > flashSyAvailable) {
+      return null
+    }
+
     const MOCK_AMOUNT = 1e9
     const mockNeeds = simulateAddLiquidity(marketState, {
       lowerTick,
@@ -1070,8 +1087,6 @@ export function simulateSwapAndSupply(
       maxPt: MOCK_AMOUNT,
       syExchangeRate,
     })
-    const searchBudget = Math.max(0, syBudget - SWAP_EXACT_OUT_SY_HEADROOM)
-
     // Wrapper flow still executes a flash swap even when external_pt_to_buy is 0
     // (effective exact-out target becomes 2 due +2 safety margin).
     let externalPtToBuy = 0
@@ -1103,6 +1118,15 @@ export function simulateSwapAndSupply(
         externalPtToBuy = Math.max(0, Math.floor(guessSwap.amountOut))
       }
     }
+    const baseSwapExactOutSyHeadroom =
+      externalPtToBuy >= SWAP_EXACT_OUT_HEADROOM_PT_THRESHOLD
+        ? SWAP_EXACT_OUT_SY_HEADROOM
+        : MIN_SWAP_EXACT_OUT_SY_HEADROOM
+    const swapExactOutSyHeadroom = syBudget >= LARGE_SWAP_AND_SUPPLY_SY_BUDGET ? 0 : baseSwapExactOutSyHeadroom
+    const simulatedOverspendTolerance =
+      syBudget >= LARGE_SWAP_AND_SUPPLY_SY_BUDGET ? MAX_SWAP_AND_SUPPLY_SIMULATED_OVERSPEND_LAMPORTS : 0
+    const searchBudget = Math.max(0, syBudget - swapExactOutSyHeadroom + simulatedOverspendTolerance)
+    const exactOutEstimateSlack = mockNeeds.sySpent === 0 ? PT_ONLY_SWAP_EXACT_OUT_ESTIMATE_SLACK : 0
 
     const candidateCache = new Map<number, SwapAndSupplyCandidate | null>()
     const evaluateCandidate = (ptConstraint: number) => {
@@ -1118,13 +1142,35 @@ export function simulateSwapAndSupply(
         syBudget,
         key,
         syExchangeRate,
+        exactOutEstimateSlack,
       )
       candidateCache.set(key, candidate)
       return candidate
     }
+
+    if (mockNeeds.ptSpent <= 0) {
+      const selected = evaluateCandidate(0)
+      if (!selected || !hasLpSupplyCapacity(marketState, selected.lpOut)) {
+        return null
+      }
+      if (!isSyDebitWithinTolerance(syBudget, selected.totalSySpent, simulatedOverspendTolerance)) {
+        return null
+      }
+
+      return {
+        lpOut: selected.lpOut,
+        ptToBuy: 0,
+        syConstraint: syBudget,
+        syForSwap: selected.tradeSySpent,
+        syRemainder: selected.syRemainderAfterSwap,
+        ptFromSwap: selected.tradePtOut,
+        syDeposited: selected.depositSySpent,
+        ptDeposited: selected.depositPtSpent,
+      }
+    }
+
     const ptCap = 1_000_000_000
     let bestUnderBudget: SwapAndSupplyCandidate | null = null
-    let leastOverspend: SwapAndSupplyCandidate | null = null
     const considerCandidate = (candidate: SwapAndSupplyCandidate | null) => {
       if (!candidate) {
         return
@@ -1139,14 +1185,6 @@ export function simulateSwapAndSupply(
         }
         return
       }
-
-      if (
-        !leastOverspend ||
-        candidate.totalSySpent < leastOverspend.totalSySpent ||
-        (candidate.totalSySpent === leastOverspend.totalSySpent && candidate.lpOut > leastOverspend.lpOut)
-      ) {
-        leastOverspend = candidate
-      }
     }
 
     // Always evaluate from zero to establish a valid lower bound.
@@ -1200,14 +1238,21 @@ export function simulateSwapAndSupply(
       considerCandidate(evaluateCandidate(pt))
     }
 
-    const selected = bestUnderBudget ?? leastOverspend
+    const selected = bestUnderBudget
     if (!selected) {
-      throw new Error("Unable to simulate swap & supply for initial PT constraint")
+      throw new Error("Unable to simulate swap & supply within SY budget")
+    }
+    if (!hasLpSupplyCapacity(marketState, selected.lpOut)) {
+      return null
+    }
+    if (!isSyDebitWithinTolerance(syBudget, selected.totalSySpent, simulatedOverspendTolerance)) {
+      return null
     }
     if (process.env.DEBUG_SWAP_SUPPLY === "1") {
       console.log("[simulateSwapAndSupply]", {
         syBudget,
         searchBudget,
+        swapExactOutSyHeadroom,
         mockNeeds,
         externalPtToBuy,
         selected,
@@ -1248,6 +1293,7 @@ function simulateSwapAndSupplyForPtConstraint(
   syBudget: number,
   ptConstraint: number,
   syExchangeRate: number,
+  exactOutEstimateSlack: number,
 ): SwapAndSupplyCandidate | null {
   let swapResult: {
     sySpent: number
@@ -1261,6 +1307,7 @@ function simulateSwapAndSupplyForPtConstraint(
       syBudget,
       ptConstraint,
       syExchangeRate,
+      exactOutEstimateSlack,
     )
   } catch {
     // Budget insufficient for this PT constraint
@@ -1268,7 +1315,6 @@ function simulateSwapAndSupplyForPtConstraint(
   }
 
   const depositState = swapResult.postMarketState ?? marketState
-  const syAvailableForDeposit = Math.max(0, syBudget - swapResult.sySpent)
   const depositResult = simulateAddLiquidity(depositState, {
     lowerTick,
     upperTick,
@@ -1302,9 +1348,39 @@ function simulateSwapAndSupplyForPtConstraint(
   }
 }
 
-function convertBaseToSyBudget(amountBase: number): number {
+function convertBaseToSyBudget(amountBase: number, syExchangeRate: number): number {
   const baseAmount = Math.max(0, Math.floor(amountBase))
-  return baseAmount
+  if (syExchangeRate <= 0) {
+    return 0
+  }
+  return Math.floor(baseAmount / syExchangeRate)
+}
+
+function hasLpSupplyCapacity(marketState: MarketThreeState, deltaL: number): boolean {
+  const deltaLiquidity = Math.ceil(deltaL)
+  if (!Number.isFinite(deltaLiquidity) || deltaLiquidity < 0 || !Number.isSafeInteger(deltaLiquidity)) {
+    return false
+  }
+
+  const liquidityBalance = BigInt(marketState.financials.liquidityBalance.toString())
+  const maxLpSupply = BigInt(marketState.configurationOptions.maxLpSupply.toString())
+
+  return liquidityBalance + BigInt(deltaLiquidity) <= maxLpSupply
+}
+
+function isSyDebitWithinTolerance(
+  syBudget: number,
+  totalSySpent: number,
+  simulatedOverspendTolerance: number,
+): boolean {
+  const targetSyDebit = Math.max(0, Math.floor(syBudget))
+  const estimatedSyDebit = Math.max(0, Math.floor(totalSySpent))
+  const underSpendLamports = targetSyDebit - estimatedSyDebit
+  if (underSpendLamports < 0) {
+    return Math.abs(underSpendLamports) <= simulatedOverspendTolerance
+  }
+
+  return underSpendLamports <= MAX_SWAP_AND_SUPPLY_UNDERSPEND_LAMPORTS
 }
 
 function simulateBuyPtExactOutWrapper(
@@ -1312,12 +1388,14 @@ function simulateBuyPtExactOutWrapper(
   syBudget: number,
   ptConstraint: number,
   syExchangeRate: number,
+  exactOutEstimateSlack: number,
 ): {
   sySpent: number
   ptOut: number
   postMarketState?: MarketThreeState
 } {
   const maxSyBudget = Math.max(0, Math.floor(syBudget))
+  const exactOutSyConstraint = maxSyBudget + Math.max(0, Math.floor(exactOutEstimateSlack))
   const effectivePtOutTarget = Math.max(0, Math.floor(ptConstraint)) + 2
 
   if (maxSyBudget === 0) {
@@ -1334,7 +1412,7 @@ function simulateBuyPtExactOutWrapper(
       amountOut: targetPtOut,
       syExchangeRate,
       isCurrentFlashSwap: true,
-      amountInConstraint: maxSyBudget,
+      amountInConstraint: exactOutSyConstraint,
     })
   }
 

package/src/swapV2.ts

@@ -3,23 +3,19 @@
  * 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"
+import { MarketThreeState, SwapArgs, SwapDirection, SwapExactOutArgs, SwapOutcomeV2 } from "./types"
+import { EffSnap, TicksWrapper, calculateFeeRate, getFeeFromAmount, normalizedTimeRemaining } from "./utilsV2"
 
 const BASE_POINTS = 10000
 
+function computeFlashFeeOut(ytValue: number, grossOut: number, lpFeeRate: number): number {
+  if (grossOut === 0) {
+    return 0
+  }
+
+  return Math.min(grossOut, Math.max(1, getFeeFromAmount(ytValue, lpFeeRate)))
+}
+
 /**
  * Simulate a swap on the CLMM market (V2 - mirrors Rust closely)
  * This is a pure function that does not mutate the market state
@@ -364,7 +360,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
         if (args.isCurrentFlashSwap) {
           const syInBase = syInSegmentU64 * args.syExchangeRate
           const ytValue = ptOutGrossU64 - syInBase
-          totalFeeOut = getFeeFromAmount(Math.max(0, Math.floor(ytValue)), lpFeeRate)
+          totalFeeOut = computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossU64, lpFeeRate)
         } else {
           totalFeeOut = getFeeFromAmount(ptOutGrossU64, lpFeeRate)
         }
@@ -605,6 +601,8 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
 
     const totalFeeOutBoundary = getFeeFromAmount(ptOutGrossBoundaryU64, lpFeeRate)
     const ptOutNetBoundary = Math.max(0, ptOutGrossBoundaryU64 - totalFeeOutBoundary)
+    let boundarySegmentSeed: ReturnType<typeof calculateSwapSegment> | null = null
+    let ptOutNetBoundaryEffectiveSeed: number | null = null
 
     if (ptOutNetBoundary === 0) {
       const boundarySegment = calculateSwapSegment(
@@ -619,87 +617,115 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
         args.isCurrentFlashSwap,
       )
 
-      let syInBoundary = boundarySegment.syInSegmentU64
-      if (ptOutGrossBoundaryU64 > 0 && syInBoundary === 0) {
-        syInBoundary = 1
-      }
+      const ptOutNetBoundaryActual = Math.max(0, boundarySegment.ptOutGrossActual - boundarySegment.totalFeeOut)
+      if (ptOutNetBoundaryActual > 0) {
+        boundarySegmentSeed = boundarySegment
+        ptOutNetBoundaryEffectiveSeed = ptOutNetBoundaryActual
+      } else {
+        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")
-      }
+        if (amountInConstraint !== undefined && amountInConsumed + syInBoundary > amountInConstraint) {
+          throw new Error("Insufficient SY budget for exact-out trade")
+        }
 
-      amountInConsumed += syInBoundary
+        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 (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(
+        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,
-          principalPt - BigInt(boundarySegment.ptOutGrossActual),
-          principalSy + BigInt(syInBoundary),
-        )
+          currentPriceSpot,
+          activeLiquidityU64,
+          activeLiquidityF64,
+        })
+        if (!crossed) break
+        currentLeftBoundaryKey = crossed.currentLeftBoundaryKey
+        currentPriceSpot = crossed.currentPriceSpot
+        activeLiquidityU64 = crossed.activeLiquidityU64
+        activeLiquidityF64 = crossed.activeLiquidityF64
+        continue
       }
+    }
 
-      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
+    let ptOutNetBoundaryEffective = ptOutNetBoundaryEffectiveSeed ?? ptOutNetBoundary
+    let precomputedBoundarySegment: ReturnType<typeof calculateSwapSegment> | null = null
+    if (amountOutLeft >= ptOutNetBoundary) {
+      const boundarySegment =
+        boundarySegmentSeed ??
+        calculateSwapSegment(
+          ptOutGrossBoundaryU64,
+          lTradeF64,
+          currentPriceSpot,
+          duToLeft,
+          anchorULeft,
+          snapshot,
+          cEffOld,
+          lpFeeRate,
+          args.isCurrentFlashSwap,
+        )
+      const ptOutNetBoundaryActual =
+        ptOutNetBoundaryEffectiveSeed ?? Math.max(0, boundarySegment.ptOutGrossActual - boundarySegment.totalFeeOut)
+      ptOutNetBoundaryEffective = ptOutNetBoundaryActual
+      if (ptOutNetBoundaryActual > 0 && amountOutLeft >= ptOutNetBoundaryActual) {
+        precomputedBoundarySegment = boundarySegment
+      }
     }
 
-    const targetNet = Math.min(amountOutLeft, ptOutNetBoundary)
-    const grossCandidate = findGrossForTargetNet(targetNet, 0, ptOutGrossBoundaryU64, (gross) =>
-      calculateNetPtOut(
-        gross,
+    const targetNet = Math.min(amountOutLeft, ptOutNetBoundaryEffective)
+    const grossCandidate = precomputedBoundarySegment
+      ? ptOutGrossBoundaryU64
+      : findGrossForTargetNet(targetNet, Math.min(targetNet, ptOutGrossBoundaryU64), ptOutGrossBoundaryU64, (gross) =>
+          calculateNetPtOut(
+            gross,
+            lTradeF64,
+            currentPriceSpot,
+            duToLeft,
+            anchorULeft,
+            lpFeeRate,
+            args.isCurrentFlashSwap,
+            snapshot,
+            cEffOld,
+          ),
+        )
+
+    const segment =
+      precomputedBoundarySegment ??
+      calculateSwapSegment(
+        grossCandidate,
         lTradeF64,
         currentPriceSpot,
         duToLeft,
         anchorULeft,
-        lpFeeRate,
-        args.isCurrentFlashSwap,
         snapshot,
         cEffOld,
-      ),
-    )
-
-    const segment = calculateSwapSegment(
-      grossCandidate,
-      lTradeF64,
-      currentPriceSpot,
-      duToLeft,
-      anchorULeft,
-      snapshot,
-      cEffOld,
-      lpFeeRate,
-      args.isCurrentFlashSwap,
-    )
+        lpFeeRate,
+        args.isCurrentFlashSwap,
+      )
 
     let syInSegmentU64 = segment.syInSegmentU64
     if (grossCandidate > 0 && syInSegmentU64 === 0) {
       syInSegmentU64 = 1
     }
 
-    if (
-      amountInConstraint !== undefined &&
-      amountInConsumed + syInSegmentU64 > amountInConstraint
-    ) {
+    if (amountInConstraint !== undefined && amountInConsumed + syInSegmentU64 > amountInConstraint) {
       throw new Error("Insufficient SY budget for exact-out trade")
     }
 
@@ -781,27 +807,11 @@ function computeKappaAndLTrade(
   let kappaPt: number
 
   if (direction === SwapDirection.SyToPt) {
-    kappaPt = isSyOnlyRange
-      ? 0
-      : ptMaxToLeftF > 0
-        ? principalPtInInterval / ptMaxToLeftF
-        : Infinity
-    kappaSy = isPtOnlyRange
-      ? 1
-      : yMaxToBoundaryF > 0
-        ? principalSyInInterval / yMaxToBoundaryF
-        : Infinity
+    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
+    kappaSy = isPtOnlyRange ? 0 : yMaxToBoundaryF > 0 ? principalSyInInterval / yMaxToBoundaryF : Infinity
+    kappaPt = isSyOnlyRange ? 1 : ptMaxToLeftF > 0 ? principalPtInInterval / ptMaxToLeftF : Infinity
   }
 
   const kappa = Math.min(kappaPt, kappaSy, 1)
@@ -823,16 +833,94 @@ function findGrossForTargetNet(
   maxGross: number,
   calculateNet: (gross: number) => number,
 ): number {
+  const MAX_INTERPOLATION_STEPS = 6
+  const MAX_LOCAL_ADJUST_STEPS = 24
+  const MAX_BINARY_FALLBACK_STEPS = 12
+
   if (minGross >= maxGross) {
     return minGross
   }
 
   let left = minGross
+  let leftNet = calculateNet(left)
+  if (leftNet >= targetNet) {
+    return left
+  }
+
   let right = maxGross
-  let bestGross = minGross
+  let rightNet = calculateNet(right)
+  if (rightNet <= targetNet) {
+    return right
+  }
+
+  for (let i = 0; i < MAX_INTERPOLATION_STEPS; i++) {
+    if (right <= left + 1) {
+      return left
+    }
+    if (rightNet <= leftNet) {
+      break
+    }
+
+    const span = right - left
+    const targetDelta = Math.max(0, targetNet - leftNet)
+    const denominator = rightNet - leftNet
+    if (denominator === 0) {
+      break
+    }
+
+    const estimatedOffset = Number((BigInt(targetDelta) * BigInt(span)) / BigInt(denominator))
+    let estimate = left + estimatedOffset
+    if (estimate <= left) {
+      estimate = left + 1
+    }
+    if (estimate >= right) {
+      estimate = right - 1
+    }
+
+    const estimateNet = calculateNet(estimate)
+    if (estimateNet === targetNet) {
+      return estimate
+    }
+    if (estimateNet < targetNet) {
+      left = estimate
+      leftNet = estimateNet
+    } else {
+      right = estimate
+      rightNet = estimateNet
+    }
+  }
+
+  let best = left
+  for (let i = 0; i < MAX_LOCAL_ADJUST_STEPS; i++) {
+    if (best >= right) {
+      break
+    }
+    const next = best + 1
+    if (next > right) {
+      break
+    }
+    const nextNet = calculateNet(next)
+    if (nextNet > targetNet) {
+      break
+    }
+    best = next
+    if (nextNet === targetNet) {
+      return best
+    }
+  }
+
+  if (right <= best + 1) {
+    return best
+  }
+
+  let low = best
+  let high = right
+  let bestGross = best
+  let steps = 0
 
-  while (left <= right) {
-    const mid = left + Math.floor((right - left) / 2)
+  while (low <= high && steps < MAX_BINARY_FALLBACK_STEPS) {
+    steps += 1
+    const mid = low + Math.floor((high - low) / 2)
     const net = calculateNet(mid)
 
     if (net === targetNet) {
@@ -841,12 +929,12 @@ function findGrossForTargetNet(
 
     if (net < targetNet) {
       bestGross = mid
-      left = mid + 1
+      low = mid + 1
     } else {
       if (mid === 0) {
         break
       }
-      right = mid - 1
+      high = mid - 1
     }
   }
 
@@ -871,10 +959,7 @@ function calculateNetPtOut(
     spotPriceNew = anchorULeft
   }
 
-  const ptOutGrossActual = Math.max(
-    0,
-    Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)),
-  )
+  const ptOutGrossActual = Math.max(0, Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)))
 
   const totalFeeOut = isCurrentFlashSwap
     ? (() => {
@@ -882,7 +967,7 @@ function calculateNetPtOut(
         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)
+        return computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossActual, lpFeeRate)
       })()
     : getFeeFromAmount(ptOutGrossActual, lpFeeRate)
 
@@ -915,15 +1000,12 @@ function calculateSwapSegment(
   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 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 flashFee = computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossActual, lpFeeRate)
   const totalFeeOut = isCurrentFlashSwap ? flashFee : normalFee
 
   return {