@exponent-labs/market-three-math 0.9.16 → 0.9.17

package/src/existingPositionEqualization.test.ts

@@ -107,6 +107,35 @@ describe("existing position equalization", () => {
     ])
   })
 
+  it("rejects overfilled crossing positions instead of producing remove plans", () => {
+    const position = makePosition()
+    position.lpBalance = 90n
+
+    expect(() => computeExistingPositionEqualization(makeTicks(), position)).toThrow(
+      "CrossingEqualizationInvariantViolated",
+    )
+  })
+
+  it("keeps fractional crossing shares and rounds token deltas up", () => {
+    const position = makePosition()
+    position.shareTrackers[0].lpShare = PRECISE_NUMBER_DENOM / 2n
+
+    const equalization = computeExistingPositionEqualization(makeTicks(), position)
+
+    expect(equalization.ptSpent).toBe(3n)
+    expect(equalization.sySpent).toBe(4n)
+    expect(equalization.plan).toEqual([
+      {
+        shareIndex: 0,
+        tickIdx: 1,
+        direction: "add",
+        shareDeltaRaw: PRECISE_NUMBER_DENOM / 2n,
+        ptDelta: 3n,
+        syDelta: 4n,
+      },
+    ])
+  })
+
   it("throws when user budgets cannot cover fixed equalization spend", () => {
     expect(() =>
       computeExistingPositionBudgetEffect({

package/src/existingPositionEqualization.ts

@@ -5,7 +5,7 @@ const PRECISE_NUMBER_DENOM = 1_000_000_000_000n
 const U64_MAX = (1n << 64n) - 1n
 const U128_MAX = (1n << 128n) - 1n
 
-export type CrossingEqualizationDirection = "add" | "remove"
+export type CrossingEqualizationDirection = "add"
 
 export type CrossingEqualizationPlanStep = {
   shareIndex: number
@@ -62,15 +62,6 @@ const checkedSubU64 = (left: bigint, right: bigint, label: string) => {
 
 const checkedMulU128 = (left: bigint, right: bigint, label: string) => assertU128(left * right, label)
 
-const ceilMulDivU128 = (left: bigint, right: bigint, denominator: bigint, label: string) => {
-  if (denominator <= 0n) {
-    throw invariantError(`${label} division by zero`)
-  }
-
-  const product = checkedMulU128(left, right, `${label} product`)
-  return assertU128(product + denominator - 1n, `${label} ceil numerator`) / denominator
-}
-
 const fastFloorU128 = (rawPreciseNumber: bigint) =>
   assertU128(rawPreciseNumber, "precise number raw") / PRECISE_NUMBER_DENOM
 
@@ -80,8 +71,11 @@ const fastMulRatioRaw = (rawPreciseNumber: bigint, numerator: bigint, denominato
   }
 
   const raw = assertU128(rawPreciseNumber, `${label} raw precise number`)
-  const product = checkedMulU128(raw, numerator, `${label} product`)
-  return product / denominator
+  const q = raw / denominator
+  const r = raw % denominator
+  const qProduct = checkedMulU128(q, numerator, `${label} quotient product`)
+  const rProduct = checkedMulU128(r, numerator, `${label} remainder product`)
+  return assertU128(qProduct + rProduct / denominator, `${label} result`)
 }
 
 const getTickByIndex = (ticks: Ticks, tickIdx: number): Tick => {
@@ -138,39 +132,41 @@ const shareIsWithinCrossingRange = (
   return shareLeftKey >= crossLeftKey && shareRightKey <= crossRightKey
 }
 
-const computeAddDeltas = (params: {
-  ownedPt: bigint
-  ownedSy: bigint
-  liquidityDelta: bigint
-  lActual: bigint
-}): [bigint, bigint] => {
-  const ptDelta =
-    params.ownedPt > 0n
-      ? assertU64(
-          ceilMulDivU128(params.ownedPt, params.liquidityDelta, params.lActual, "PT equalization in"),
-          "PT equalization in",
-        )
-      : 0n
-  const syDelta =
-    params.ownedSy > 0n
-      ? assertU64(
-          ceilMulDivU128(params.ownedSy, params.liquidityDelta, params.lActual, "SY equalization in"),
-          "SY equalization in",
-        )
-      : 0n
+const mulNumberRatioCeilU64 = (amount: bigint, valueRaw: bigint, denominator: bigint, label: string): bigint => {
+  if (amount === 0n || valueRaw === 0n) {
+    return 0n
+  }
+  if (denominator <= 0n) {
+    throw invariantError(`${label} division by zero`)
+  }
 
-  return [ptDelta, syDelta]
+  const raw = assertU128(valueRaw, `${label} raw precise number`)
+  const int = raw / PRECISE_NUMBER_DENOM
+  const frac = raw % PRECISE_NUMBER_DENOM
+  const intNumerator = checkedMulU128(amount, int, `${label} integer numerator`)
+  const quotient = intNumerator / denominator
+  const remainder = intNumerator % denominator
+  const fractionalNumerator = checkedMulU128(amount, frac, `${label} fractional numerator`)
+  const denominatorScaled = checkedMulU128(denominator, PRECISE_NUMBER_DENOM, `${label} scaled denominator`)
+  const remainderNumerator = checkedMulU128(remainder, PRECISE_NUMBER_DENOM, `${label} remainder numerator`)
+  const ceilNumerator = assertU128(remainderNumerator + fractionalNumerator, `${label} ceil numerator`)
+  const roundedRemainder = (ceilNumerator + denominatorScaled - 1n) / denominatorScaled
+
+  return assertU64(quotient + roundedRemainder, label)
 }
 
-const computeRemoveDeltas = (params: { shareDeltaRaw: bigint; node: Tick; supply: bigint }): [bigint, bigint] => {
-  const burnShares = fastFloorU128(params.shareDeltaRaw)
-  const ptDelta = assertU64(
-    checkedMulU128(burnShares, params.node.principalPt, "PT equalization out product") / params.supply,
-    "PT equalization out",
+const computeAddDeltas = (params: { node: Tick; shareDeltaRaw: bigint; supply: bigint }): [bigint, bigint] => {
+  const ptDelta = mulNumberRatioCeilU64(
+    params.node.principalPt,
+    params.shareDeltaRaw,
+    params.supply,
+    "PT equalization in",
   )
-  const syDelta = assertU64(
-    checkedMulU128(burnShares, params.node.principalSy, "SY equalization out product") / params.supply,
-    "SY equalization out",
+  const syDelta = mulNumberRatioCeilU64(
+    params.node.principalSy,
+    params.shareDeltaRaw,
+    params.supply,
+    "SY equalization in",
   )
 
   return [ptDelta, syDelta]
@@ -183,14 +179,8 @@ const summarizePlan = (plan: CrossingEqualizationPlanStep[]): ExistingPositionEq
   let ptReleased = 0n
 
   for (const step of plan) {
-    if (step.direction === "add") {
-      sySpent = checkedAddU64(sySpent, step.syDelta, "equalization sy spent")
-      ptSpent = checkedAddU64(ptSpent, step.ptDelta, "equalization pt spent")
-      continue
-    }
-
-    syReleased = checkedAddU64(syReleased, step.syDelta, "equalization sy released")
-    ptReleased = checkedAddU64(ptReleased, step.ptDelta, "equalization pt released")
+    sySpent = checkedAddU64(sySpent, step.syDelta, "equalization sy spent")
+    ptSpent = checkedAddU64(ptSpent, step.ptDelta, "equalization pt spent")
   }
 
   return {
@@ -225,15 +215,16 @@ export function computeExistingPositionEqualization(
   if (lpBalance === lActual) {
     return summarizePlan([])
   }
+  if (lpBalance < lActual) {
+    throw invariantError("active crossing split is overfilled")
+  }
   if (lActual === 0n) {
     throw invariantError("active crossing split has zero actual liquidity")
   }
 
-  const direction: CrossingEqualizationDirection = lpBalance > lActual ? "add" : "remove"
-  const liquidityDelta = lpBalance > lActual ? lpBalance - lActual : lActual - lpBalance
+  const direction: CrossingEqualizationDirection = "add"
+  const liquidityDelta = lpBalance - lActual
   const plan: CrossingEqualizationPlanStep[] = []
-  let sawCrossingRangeShare = false
-  let skippedCrossingShareDueToDust = false
 
   for (let shareIndex = 0; shareIndex < position.shareTrackers.length; shareIndex++) {
     const share = position.shareTrackers[shareIndex]
@@ -241,43 +232,24 @@ export function computeExistingPositionEqualization(
       continue
     }
 
-    sawCrossingRangeShare = true
     const node = getTickByIndex(ticks, share.tickIdx)
     const supply = fastFloorU128(node.principalShareSupply)
     if (supply === 0n) {
-      skippedCrossingShareDueToDust = true
       continue
     }
 
-    const shareFloor = fastFloorU128(share.lpShare)
-    if (shareFloor === 0n) {
-      skippedCrossingShareDueToDust = true
+    if (share.lpShare === 0n) {
       continue
     }
 
-    const ownedPt = assertU64(checkedMulU128(shareFloor, node.principalPt, "owned PT product") / supply, "owned PT")
-    const ownedSy = assertU64(checkedMulU128(shareFloor, node.principalSy, "owned SY product") / supply, "owned SY")
     const shareDeltaRaw = fastMulRatioRaw(share.lpShare, liquidityDelta, lActual, "share delta")
-
-    let deltas: [bigint, bigint]
-    if (direction === "add") {
-      deltas = computeAddDeltas({
-        ownedPt,
-        ownedSy,
-        liquidityDelta,
-        lActual,
-      })
-    } else {
-      deltas = computeRemoveDeltas({
-        shareDeltaRaw,
-        node,
-        supply,
-      })
-    }
-    const [ptDelta, syDelta] = deltas
+    const [ptDelta, syDelta] = computeAddDeltas({
+      node,
+      shareDeltaRaw,
+      supply,
+    })
 
     if (shareDeltaRaw === 0n && ptDelta === 0n && syDelta === 0n) {
-      skippedCrossingShareDueToDust = true
       continue
     }
 
@@ -291,9 +263,6 @@ export function computeExistingPositionEqualization(
     })
   }
 
-  if (plan.length === 0 && sawCrossingRangeShare && skippedCrossingShareDueToDust) {
-    return summarizePlan([])
-  }
   if (plan.length === 0) {
     throw invariantError("active crossing split has no equalizable crossing-range shares")
   }
@@ -338,8 +307,8 @@ export function computeExistingPositionBudgetEffect(params: {
 }
 
 /**
- * Mirrors `required_user_max_sy/pt`: expands a desired post-equalization budget
- * into the user-facing max token amounts that should be passed to the instruction.
+ * Expands a desired post-equalization budget into user-facing max token inputs.
+ * This is the algebraic inverse of `computeExistingPositionBudgetEffect`.
  */
 export function computeRequiredUserMaxForExistingPositionEqualization(params: {
   ticks: Ticks

package/src/index.ts

@@ -48,8 +48,6 @@ export {
   simulateAddLiquidity,
   computeLiquidityTargetAndTokenNeeds,
   computeTokenNeedsWithCrossing,
-  getCrossingTickStateFromTicks,
-  scaleCrossingTickInputs,
   calculateLpOut,
   estimateBalancedDeposit,
   calcDepositSyAndPtFromBaseAmount,
@@ -84,8 +82,6 @@ export type {
   AddLiquidityArgs,
   AddLiquidityOutcome,
   LiquidityNeeds,
-  CrossingTickState,
-  CrossingScaleParams,
   MarketThreeState,
 } from "./types"
 export { SwapDirection } from "./types"

package/src/swap.ts

@@ -309,6 +309,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
     amountOut: amountOutNet,
     lpFeeChargedOutToken: feeLpOut,
     protocolFeeChargedOutToken: feeProtocolOut,
+    boundaryRemainderChargedOutToken: 0,
     finalSpotPrice: currentPriceSpot,
     finalTickIndex: currentLeftBoundaryIndex,
   }

package/src/swapV2.ts

@@ -16,6 +16,27 @@ function computeFlashFeeOut(ytValue: number, grossOut: number, lpFeeRate: number
   return Math.min(grossOut, Math.max(1, getFeeFromAmount(ytValue, lpFeeRate)))
 }
 
+function boundaryPrincipalRemainder(
+  computedGrossOut: number,
+  fullOutgoingPrincipal: number,
+  reachesBoundary: boolean,
+): number {
+  if (!reachesBoundary) return 0
+  return Math.max(0, fullOutgoingPrincipal - Math.min(computedGrossOut, fullOutgoingPrincipal))
+}
+
+function splitFeeWithBoundaryRemainderAsLpFee(
+  totalFeeOut: number,
+  boundaryRemainder: number,
+  protocolFeeBps: number,
+): { lpFeeOut: number; protocolFeeOut: number } {
+  const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
+  return {
+    lpFeeOut: totalFeeOut - protocolFeeOut + boundaryRemainder,
+    protocolFeeOut,
+  }
+}
+
 /**
  * Simulate a swap on the CLMM market (V2 - mirrors Rust closely)
  * This is a pure function that does not mutate the market state
@@ -62,6 +83,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
   let amountOutNetU64 = 0
   let feeLpOutU64 = 0
   let feeProtocolOutU64 = 0
+  let boundaryRemainderChargedOutToken = 0
   let amountInLeft = args.amountIn
 
   if (DEBUG) {
@@ -227,10 +249,16 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       const anchorUNew = currentPriceSpot + duActual
       const cEffNew = snapshot.getEffectivePrice(anchorUNew)
       const syOutGrossF = lTradeF64 * (cEffOld - cEffNew)
+      const reachesRightBoundary = Math.abs(anchorURight - anchorUNew) <= eps
 
       // Clamp by SY principal
       let syOutGrossU64 = Math.floor(syOutGrossF)
       syOutGrossU64 = Math.min(syOutGrossU64, Number(principalSy))
+      const syRemainderAtBoundary = boundaryPrincipalRemainder(
+        syOutGrossU64,
+        Number(principalSy),
+        reachesRightBoundary,
+      )
 
       if (DEBUG) {
         console.log(`  ptInSegment=${ptInSegment}, syOutGrossU64=${syOutGrossU64}`)
@@ -238,7 +266,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
 
       // 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) {
+      if (syOutGrossU64 > 0 || syRemainderAtBoundary > 0) {
         let totalFeeOut: number
         if (args.isCurrentFlashSwap) {
           const syOutBase = syOutGrossU64 * args.syExchangeRate
@@ -248,21 +276,25 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
         } else {
           totalFeeOut = getFeeFromAmount(syOutGrossU64, lpFeeRate)
         }
-        const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
-        const lpFeeOut = totalFeeOut - protocolFeeOut
+        const { lpFeeOut, protocolFeeOut } = splitFeeWithBoundaryRemainderAsLpFee(
+          totalFeeOut,
+          syRemainderAtBoundary,
+          protocolFeeBps,
+        )
         const syOutNet = syOutGrossU64 - totalFeeOut
 
         // Accumulate to user
         amountOutNetU64 += syOutNet
         feeLpOutU64 += lpFeeOut
         feeProtocolOutU64 += protocolFeeOut
+        boundaryRemainderChargedOutToken += syRemainderAtBoundary
 
         // Mirror on-chain principal mutation for this interval:
         // +PT input (gross), -SY output (gross)
         ticksWrapper.setPrincipals(
           currentLeftBoundaryKey,
           principalPt + BigInt(ptInSegment),
-          principalSy - BigInt(syOutGrossU64),
+          reachesRightBoundary ? 0n : principalSy - BigInt(syOutGrossU64),
         )
 
         // Consume input and advance state
@@ -320,6 +352,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       // New effective price and spot after consuming ΔC
       const cEffNew = cEffOld + deltaCActual
       const spotPriceNew = snapshot.spotPriceFromEffectivePrice(cEffNew)
+      const reachesLeftBoundary = Math.abs(cEffNew - cEffLeft) <= eps || Math.abs(spotPriceNew - anchorULeft) <= eps
 
       // Token flows
       const syInSegmentF = lTradeF64 * (cEffNew - cEffOld)
@@ -329,6 +362,11 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       // Clamp gross PT by available principal
       let ptOutGrossU64 = Math.floor(ptOutGrossF)
       ptOutGrossU64 = Math.min(ptOutGrossU64, Number(principalPt))
+      const ptRemainderAtBoundary = boundaryPrincipalRemainder(
+        ptOutGrossU64,
+        Number(principalPt),
+        reachesLeftBoundary,
+      )
       // ceil for input to protect pool
       const syInSegmentU64 = Math.ceil(syInSegmentF)
 
@@ -338,7 +376,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       }
 
       // Match on-chain behavior: if no PT can be taken from this interval, cross and continue.
-      if (ptOutGrossU64 === 0) {
+      if (ptOutGrossU64 === 0 && ptRemainderAtBoundary === 0) {
         const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
           currentLeftBoundaryKey,
           currentPriceSpot,
@@ -353,7 +391,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
         continue
       }
 
-      if (ptOutGrossU64 > 0) {
+      if (ptOutGrossU64 > 0 || ptRemainderAtBoundary > 0) {
         // Fees in token_out (PT)
         // For flash swaps, fee is based on YT value = pt - sy × sy_exchange_rate
         let totalFeeOut: number
@@ -364,20 +402,24 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
         } else {
           totalFeeOut = getFeeFromAmount(ptOutGrossU64, lpFeeRate)
         }
-        const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS)
-        const lpFeeOut = totalFeeOut - protocolFeeOut
+        const { lpFeeOut, protocolFeeOut } = splitFeeWithBoundaryRemainderAsLpFee(
+          totalFeeOut,
+          ptRemainderAtBoundary,
+          protocolFeeBps,
+        )
         const ptOutNet = ptOutGrossU64 - totalFeeOut
 
         // Accumulate to user
         amountOutNetU64 += ptOutNet
         feeLpOutU64 += lpFeeOut
         feeProtocolOutU64 += protocolFeeOut
+        boundaryRemainderChargedOutToken += ptRemainderAtBoundary
 
         // Mirror on-chain principal mutation for this interval:
         // +SY input (gross), -PT output (gross)
         ticksWrapper.setPrincipals(
           currentLeftBoundaryKey,
-          principalPt - BigInt(ptOutGrossU64),
+          reachesLeftBoundary ? 0n : principalPt - BigInt(ptOutGrossU64),
           principalSy + BigInt(syInSegmentU64),
         )
       }
@@ -414,6 +456,7 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
     amountOut: amountOutNetU64,
     lpFeeChargedOutToken: feeLpOutU64,
     protocolFeeChargedOutToken: feeProtocolOutU64,
+    boundaryRemainderChargedOutToken,
     finalSpotPrice: currentPriceSpot,
     finalTickKey: currentLeftBoundaryKey, // This is now the key, not array index
     postMarketState,
@@ -457,6 +500,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
       amountOut: 0,
       lpFeeChargedOutToken: 0,
       protocolFeeChargedOutToken: 0,
+      boundaryRemainderChargedOutToken: 0,
       finalSpotPrice: currentPriceSpot,
       finalTickKey: currentLeftBoundaryKey,
       postMarketState: marketState,
@@ -468,6 +512,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
   let amountInConsumed = 0
   let feeLpOutU64 = 0
   let feeProtocolOutU64 = 0
+  let boundaryRemainderChargedOutToken = 0
 
   let iterations = 0
   const MAX_ITERATIONS = 1000
@@ -498,8 +543,15 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     const cEffOld = snapshot.getEffectivePrice(currentPriceSpot)
     const cEffLeft = snapshot.getEffectivePrice(anchorULeft)
     const deltaCToLeftBoundary = cEffLeft - cEffOld
+    const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentLeftBoundaryKey)
 
     if (!Number.isFinite(deltaCToLeftBoundary) || deltaCToLeftBoundary <= eps) {
+      if (Number.isFinite(deltaCToLeftBoundary) && deltaCToLeftBoundary <= eps && principalPt > 0n) {
+        const ptRemainderAtBoundary = Number(principalPt)
+        feeLpOutU64 += ptRemainderAtBoundary
+        boundaryRemainderChargedOutToken += ptRemainderAtBoundary
+        ticksWrapper.setPrincipals(currentLeftBoundaryKey, 0n, principalSy)
+      }
       const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
         currentLeftBoundaryKey,
         currentPriceSpot,
@@ -514,8 +566,6 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
       continue
     }
 
-    const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentLeftBoundaryKey)
-
     const duToLeft = currentPriceSpot - anchorULeft
     if (!Number.isFinite(duToLeft) || deltaCToLeftBoundary <= eps) {
       const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
@@ -585,6 +635,12 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     ptOutGrossBoundaryU64 = Math.min(ptOutGrossBoundaryU64, Number(principalPt))
 
     if (ptOutGrossBoundaryU64 === 0) {
+      const ptRemainderAtBoundary = boundaryPrincipalRemainder(0, Number(principalPt), true)
+      feeLpOutU64 += ptRemainderAtBoundary
+      boundaryRemainderChargedOutToken += ptRemainderAtBoundary
+      if (ptRemainderAtBoundary > 0) {
+        ticksWrapper.setPrincipals(currentLeftBoundaryKey, 0n, principalSy)
+      }
       const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
         currentLeftBoundaryKey,
         currentPriceSpot,
@@ -633,17 +689,26 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
 
         amountInConsumed += syInBoundary
 
-        if (boundarySegment.totalFeeOut > 0) {
-          const protocolFeeOut = Math.floor((boundarySegment.totalFeeOut * protocolFeeBps) / BASE_POINTS)
-          const lpFeeOut = boundarySegment.totalFeeOut - protocolFeeOut
+        const ptRemainderAtBoundary = boundaryPrincipalRemainder(
+          boundarySegment.ptOutGrossActual,
+          Number(principalPt),
+          true,
+        )
+        if (boundarySegment.totalFeeOut > 0 || ptRemainderAtBoundary > 0) {
+          const { lpFeeOut, protocolFeeOut } = splitFeeWithBoundaryRemainderAsLpFee(
+            boundarySegment.totalFeeOut,
+            ptRemainderAtBoundary,
+            protocolFeeBps,
+          )
           feeLpOutU64 += lpFeeOut
           feeProtocolOutU64 += protocolFeeOut
+          boundaryRemainderChargedOutToken += ptRemainderAtBoundary
         }
 
         if (syInBoundary > 0 || boundarySegment.ptOutGrossActual > 0) {
           ticksWrapper.setPrincipals(
             currentLeftBoundaryKey,
-            principalPt - BigInt(boundarySegment.ptOutGrossActual),
+            0n,
             principalSy + BigInt(syInBoundary),
           )
         }
@@ -740,14 +805,26 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     amountOutAccum += netActual
     amountInConsumed += syInSegmentU64
 
-    const protocolFeeOut = Math.floor((segment.totalFeeOut * protocolFeeBps) / BASE_POINTS)
-    const lpFeeOut = segment.totalFeeOut - protocolFeeOut
+    const reachesLeftBoundary =
+      Math.abs(snapshot.getEffectivePrice(segment.spotPriceNew) - cEffLeft) <= eps ||
+      segment.ptOutGrossActual === ptOutGrossBoundaryU64
+    const ptRemainderAtBoundary = boundaryPrincipalRemainder(
+      segment.ptOutGrossActual,
+      Number(principalPt),
+      reachesLeftBoundary,
+    )
+    const { lpFeeOut, protocolFeeOut } = splitFeeWithBoundaryRemainderAsLpFee(
+      segment.totalFeeOut,
+      ptRemainderAtBoundary,
+      protocolFeeBps,
+    )
     feeLpOutU64 += lpFeeOut
     feeProtocolOutU64 += protocolFeeOut
+    boundaryRemainderChargedOutToken += ptRemainderAtBoundary
 
     ticksWrapper.setPrincipals(
       currentLeftBoundaryKey,
-      principalPt - BigInt(segment.ptOutGrossActual),
+      reachesLeftBoundary ? 0n : principalPt - BigInt(segment.ptOutGrossActual),
       principalSy + BigInt(syInSegmentU64),
     )
 
@@ -786,6 +863,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     amountOut: amountOutAccum,
     lpFeeChargedOutToken: feeLpOutU64,
     protocolFeeChargedOutToken: feeProtocolOutU64,
+    boundaryRemainderChargedOutToken,
     finalSpotPrice: currentPriceSpot,
     finalTickKey: currentLeftBoundaryKey,
     postMarketState,

package/src/types.ts

@@ -53,6 +53,8 @@ export interface SwapOutcome {
   lpFeeChargedOutToken: number
   /** Protocol fee charged in out token */
   protocolFeeChargedOutToken: number
+  /** Boundary principal remainder distributed to LPs in out token */
+  boundaryRemainderChargedOutToken: number
   /** Final spot price after swap */
   finalSpotPrice: number
   /** Final tick index after swap */
@@ -68,6 +70,8 @@ export interface SwapOutcomeV2 {
   lpFeeChargedOutToken: number
   /** Protocol fee charged in out token */
   protocolFeeChargedOutToken: number
+  /** Boundary principal remainder distributed to LPs in out token */
+  boundaryRemainderChargedOutToken: number
   /** Final spot price after swap */
   finalSpotPrice: number
   /** Final tick key after swap */
@@ -109,27 +113,4 @@ export interface LiquidityNeeds {
   priceSplitForNeed: number
   /** Tick index of the split point */
   priceSplitTickIdx: number
-  /** Original max SY before CLMM trimming (for crossing tick scaling) */
-  originalMaxSy: number
-  /** Original max PT before CLMM trimming (for crossing tick scaling) */
-  originalMaxPt: number
-  /** PT distribution extent: current_spot - lower_price */
-  duLeftTotal: number
-  /** SY distribution extent: eff_price_current - eff_price_upper */
-  deltaCRightTotal: number
-}
-
-/** State of the crossing (current) tick for proportional distribution */
-export interface CrossingTickState {
-  principalPt: number
-  principalSy: number
-  principalShareSupply: number
-}
-
-/** Parameters for scaling crossing tick inputs from original max values */
-export interface CrossingScaleParams {
-  originalMaxSy: number
-  originalMaxPt: number
-  duLeftTotal: number
-  deltaCRightTotal: number
 }

package/src/utilsV2.ts

@@ -273,9 +273,7 @@ export class TicksWrapper {
       apyBasePoints: key,
       principalShareSupply: 0n,
       farms: templateTick ? templateTick.farms.map(() => ({ lastSeenIndex: 0 })) : [],
-      emissions: templateTick
-        ? templateTick.emissions.map(() => ({ lastSeenIndex: 0, lastPositionIndex: 0 }))
-        : [],
+      emissions: templateTick ? templateTick.emissions.map(() => ({ lastSeenIndex: 0, lastPositionIndex: 0 })) : [],
       lastSplitEpoch: 0n,
       splitParentEpoch: 0n,
       frozenLiquidity: 0n,
@@ -287,6 +285,10 @@ export class TicksWrapper {
     this.sortedKeys.push(key)
     this.sortedKeys.sort((a, b) => a - b)
 
+    if (newTick.impliedRate <= this.currentSpotPrice && key > this.currentTickKey) {
+      this.currentTickKey = key
+    }
+
     this.splitPrincipalsAfterInsert(key, snap)
   }
 
@@ -301,7 +303,8 @@ export class TicksWrapper {
     const currentTickIdx = this.baseTicksTree.findIndex((tick) => tick.apyBasePoints === currentTickKey)
     const fallbackTickKey = this.findTickKeyBySpotPrice(currentSpotPrice)
     const fallbackTickIdx = this.baseTicksTree.findIndex((tick) => tick.apyBasePoints === fallbackTickKey)
-    const resolvedCurrentTick = currentTickIdx >= 0 ? currentTickIdx + 1 : fallbackTickIdx >= 0 ? fallbackTickIdx + 1 : 0
+    const resolvedCurrentTick =
+      currentTickIdx >= 0 ? currentTickIdx + 1 : fallbackTickIdx >= 0 ? fallbackTickIdx + 1 : 0
 
     return {
       currentTick: resolvedCurrentTick,