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

package/src/addLiquidity.ts

@@ -2,19 +2,17 @@
  * CLMM Add Liquidity simulation
  * Ported from exponent_clmm/src/state/market_three/helpers/add_liquidity.rs
  */
-import { Ticks } from "@exponent-labs/exponent-fetcher"
+import type { LpPositionCLMM, Ticks } from "@exponent-labs/exponent-fetcher"
 
+import { computeExistingPositionBudgetEffect } from "./existingPositionEqualization"
 import { simulateSwap, simulateSwapExactOut } from "./swapV2"
 import {
   AddLiquidityArgs,
   AddLiquidityOutcome,
-  CrossingScaleParams,
-  CrossingTickState,
   LiquidityNeeds,
   MarketThreeState,
   SwapDirection,
 } from "./types"
-import { findTickByKey, getSuccessorTickKey } from "./utils"
 import { EffSnap, TicksWrapper, normalizedTimeRemaining } from "./utilsV2"
 
 const TICK_KEY_BASE_POINTS = 1_000_000
@@ -24,49 +22,16 @@ 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 ZERO_BIGINT = 0n
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER)
 
-const EMPTY_CROSSING_TICK_STATE: CrossingTickState = {
-  principalPt: 0,
-  principalSy: 0,
-  principalShareSupply: 0,
-}
-
-/**
- * Get crossing tick state and price boundaries from Ticks.
- * Matches wrapper_provide_liquidity.rs: current node's spot_price, principal_pt/sy/supply, successor's spot_price.
- */
-export function getCrossingTickStateFromTicks(ticks: Ticks): {
-  crossingTickState: CrossingTickState
-  crossingTickPriceLeft: number
-  crossingTickPriceRight: number
-} {
-  const currentTickNode = ticks.ticksTree[ticks.currentTick - 1]
-  if (!currentTickNode || ticks.currentTick <= 0) {
-    return {
-      crossingTickState: EMPTY_CROSSING_TICK_STATE,
-      crossingTickPriceLeft: 0,
-      crossingTickPriceRight: 0,
-    }
-  }
-  const crossingTickPriceLeft = currentTickNode.impliedRate
-  const successorKey = getSuccessorTickKey(ticks, currentTickNode.apyBasePoints)
-  const successorTick = successorKey != null ? findTickByKey(ticks, successorKey)?.tick : null
-  const crossingTickPriceRight = successorTick?.impliedRate ?? Number.POSITIVE_INFINITY
-  return {
-    crossingTickState: {
-      principalPt: Number(currentTickNode.principalPt),
-      principalSy: Number(currentTickNode.principalSy),
-      principalShareSupply: Number(currentTickNode.principalShareSupply),
-    },
-    crossingTickPriceLeft,
-    crossingTickPriceRight,
-  }
+type AddLiquiditySimulationOptions = {
+  existingPosition?: LpPositionCLMM
 }
 
 /**
@@ -103,11 +68,6 @@ export function computeLiquidityTargetAndTokenNeeds(
       ptNeeded: 0,
       priceSplitForNeed: lowerPrice,
       priceSplitTickIdx: lowerTickIdx,
-      // No crossing possible when below range
-      originalMaxSy: maxSy,
-      originalMaxPt: maxPt,
-      duLeftTotal: 0,
-      deltaCRightTotal: deltaCTotal,
     }
   } else if (spotPriceCurrent >= upperPrice) {
     // Above range: PT only (NOT SY!)
@@ -122,11 +82,6 @@ export function computeLiquidityTargetAndTokenNeeds(
       ptNeeded: Math.floor(ptNeed),
       priceSplitForNeed: upperPrice,
       priceSplitTickIdx: upperTickIdx,
-      // No crossing possible when above range
-      originalMaxSy: maxSy,
-      originalMaxPt: maxPt,
-      duLeftTotal: duTotal,
-      deltaCRightTotal: 0,
     }
   } else {
     // Inside range: both sides - crossing tick possible
@@ -147,95 +102,39 @@ export function computeLiquidityTargetAndTokenNeeds(
       ptNeeded: Math.floor(ptNeed),
       priceSplitForNeed: spotPriceCurrent,
       priceSplitTickIdx: currentIndex,
-      // Store for crossing tick scaling
-      originalMaxSy: maxSy,
-      originalMaxPt: maxPt,
-      duLeftTotal: duLeft,
-      deltaCRightTotal: deltaCRight,
     }
   }
 }
 
-/**
- * Scale crossing tick token inputs from original max values to prevent double trimming.
- *
- * When adding liquidity that spans the current price (crossing tick), tokens get trimmed twice:
- * 1. First by CLMM formula in computeLiquidityTargetAndTokenNeeds
- * 2. Then by AMM formula in simulateAddLiquidityProportional
- *
- * This function calculates the segment's proportion of the total distribution and scales
- * the original max values accordingly, ensuring maximum token utilization.
- *
- * @param scaleParams - Original max values and CLMM distribution extents
- * @param duPtPart - PT segment length (spot price delta for this segment)
- * @param syPerL1 - SY per unit liquidity for this segment
- * @param clmmPtDelta - PT amount calculated from CLMM formula
- * @param clmmSyDelta - SY amount calculated from CLMM formula
- * @returns Tuple of [scaledPtIn, scaledSyIn] - maximum of CLMM-calculated and scaled original values
- */
-export function scaleCrossingTickInputs(
-  scaleParams: CrossingScaleParams,
-  duPtPart: number,
-  syPerL1: number,
-  clmmPtDelta: number,
-  clmmSyDelta: number,
-): [number, number] {
-  const { duLeftTotal, deltaCRightTotal, originalMaxPt, originalMaxSy } = scaleParams
-
-  if (duLeftTotal > 0 && deltaCRightTotal > 0) {
-    // Calculate segment's proportion of total distribution
-    const ptSegmentRatio = duPtPart / duLeftTotal
-    const sySegmentRatio = syPerL1 / deltaCRightTotal
-
-    // Scale original max values by segment proportion
-    const scaledPt = Math.ceil(originalMaxPt * ptSegmentRatio)
-    const scaledSy = Math.ceil(originalMaxSy * sySegmentRatio)
+function toU64BigInt(value: number): bigint {
+  return BigInt(Math.max(0, Math.floor(value)))
+}
 
-    // Use max of CLMM-calculated value and scaled original value
-    // This ensures we don't lose tokens due to double trimming
-    return [Math.max(clmmPtDelta, scaledPt), Math.max(clmmSyDelta, scaledSy)]
+function lamportsNumberToBigInt(value: number, label: string): bigint {
+  const lamports = Math.max(0, Math.floor(value))
+  if (!Number.isSafeInteger(lamports)) {
+    throw new Error(`${label} exceeds JS safe integer range: ${value}`)
   }
-
-  // Fallback to original logic if no crossing scale params
-  return [clmmPtDelta, clmmSyDelta]
+  return BigInt(lamports)
 }
 
-/**
- * Simulate the proportional add_liquidity logic
- * Returns [usedPt, usedSy] based on existing tick proportions
- */
-function simulateAddLiquidityProportional(
-  intentPt: number,
-  intentSy: number,
-  marketTotalPt: number,
-  marketTotalSy: number,
-  marketTotalLp: number,
-): [number, number] {
-  if (marketTotalLp === 0 || marketTotalPt === 0 || marketTotalSy === 0) {
-    // Empty tick - use all intended amounts
-    return [intentPt, intentSy]
+function safeLamportsBigIntToNumber(value: bigint, label: string): number {
+  if (value < ZERO_BIGINT || value > MAX_SAFE_INTEGER_BIGINT) {
+    throw new Error(`${label} exceeds JS safe integer range: ${value.toString()}`)
   }
 
-  const lpFromPt = (marketTotalLp * intentPt) / marketTotalPt
-  const lpFromSy = (marketTotalLp * intentSy) / marketTotalSy
-
-  if (lpFromPt < lpFromSy) {
-    // PT is the limiting factor
-    const lpTokensOut = lpFromPt
-    const usedPt = intentPt
-    const usedSy = Math.ceil((marketTotalSy * lpTokensOut) / marketTotalLp)
-    return [usedPt, usedSy]
-  } else {
-    // SY is the limiting factor
-    const lpTokensOut = lpFromSy
-    const usedSy = intentSy
-    const usedPt = Math.ceil((marketTotalPt * lpTokensOut) / marketTotalLp)
-    return [usedPt, usedSy]
-  }
+  return Number(value)
 }
 
-function toU64BigInt(value: number): bigint {
-  return BigInt(Math.max(0, Math.floor(value)))
+function finalizeEqualizedSpend(params: {
+  simulatedSpend: number
+  fixedSpent: bigint
+  fixedReleased: bigint
+  label: string
+}): number {
+  const grossSpend = lamportsNumberToBigInt(params.simulatedSpend, params.label) + params.fixedSpent
+  const finalSpend = grossSpend > params.fixedReleased ? grossSpend - params.fixedReleased : ZERO_BIGINT
+  return safeLamportsBigIntToNumber(finalSpend, params.label)
 }
 
 function ceilDivBigInt(numerator: bigint, denominator: bigint): bigint {
@@ -285,6 +184,104 @@ function getVirtualTickState(
   return state
 }
 
+function ceilNormalizedPrincipal(value: number, cap: bigint): bigint {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error("Invalid active tick normalization value")
+  }
+
+  const capNumber = Number(cap)
+  if (value >= capNumber) {
+    return cap
+  }
+
+  return BigInt(Math.min(Math.ceil(value), capNumber))
+}
+
+function computeNormalizedActiveTickPrincipals(params: {
+  principalPt: bigint
+  principalSy: bigint
+  ptPerL: number
+  syPerL: number
+}): { normalizedPt: bigint; normalizedSy: bigint } {
+  const { principalPt, principalSy, ptPerL, syPerL } = params
+  if (!Number.isFinite(ptPerL) || !Number.isFinite(syPerL) || ptPerL < 0 || syPerL < 0) {
+    throw new Error("Invalid active tick normalization ratio")
+  }
+
+  if (ptPerL === 0 && syPerL === 0) {
+    return { normalizedPt: 0n, normalizedSy: 0n }
+  }
+  if (ptPerL === 0) {
+    return { normalizedPt: 0n, normalizedSy: principalSy }
+  }
+  if (syPerL === 0) {
+    return { normalizedPt: principalPt, normalizedSy: 0n }
+  }
+
+  const lFromPt = Number(principalPt) / ptPerL
+  const lFromSy = Number(principalSy) / syPerL
+  if (!Number.isFinite(lFromPt) || !Number.isFinite(lFromSy)) {
+    throw new Error("Invalid active tick normalization liquidity")
+  }
+
+  if (lFromPt <= lFromSy) {
+    return {
+      normalizedPt: principalPt,
+      normalizedSy: ceilNormalizedPrincipal(lFromPt * syPerL, principalSy),
+    }
+  }
+
+  return {
+    normalizedPt: ceilNormalizedPrincipal(lFromSy * ptPerL, principalPt),
+    normalizedSy: principalSy,
+  }
+}
+
+function normalizeActiveTickPrincipalsBeforeDeposit(
+  ticksWrapper: TicksWrapper,
+  snap: EffSnap,
+  lowerTickKey: number,
+  upperTickKey: number,
+): void {
+  if (ticksWrapper.currentPrefixSum === 0n) {
+    return
+  }
+
+  const currentTickKey = ticksWrapper.currentTickKey
+  if (lowerTickKey > currentTickKey || currentTickKey >= upperTickKey) {
+    return
+  }
+
+  const rightTickKey = ticksWrapper.successorKey(currentTickKey)
+  if (rightTickKey == null) {
+    return
+  }
+
+  const spotPrice = ticksWrapper.currentSpotPrice
+  const leftPrice = ticksWrapper.getSpotPrice(currentTickKey)
+  const rightPrice = ticksWrapper.getSpotPrice(rightTickKey)
+  if (spotPrice < leftPrice || spotPrice > rightPrice) {
+    return
+  }
+
+  const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentTickKey)
+  if (principalPt === 0n && principalSy === 0n) {
+    return
+  }
+
+  const ptPerL = Math.max(spotPrice - leftPrice, 0)
+  const syPerL =
+    spotPrice >= rightPrice ? 0 : snap.getEffectivePrice(spotPrice) - snap.getEffectivePrice(rightPrice)
+  const { normalizedPt, normalizedSy } = computeNormalizedActiveTickPrincipals({
+    principalPt,
+    principalSy,
+    ptPerL,
+    syPerL,
+  })
+
+  ticksWrapper.setPrincipals(currentTickKey, normalizedPt, normalizedSy)
+}
+
 function simulateMintSharesForTickPrestateCalcUsed(params: {
   key: number
   dptIn: bigint
@@ -390,8 +387,6 @@ function simulateAccruePrincipalForDeposit(params: {
   lowerTickKey: number
   upperTickKey: number
   liquidityTarget: number
-  originalMaxSy: number
-  originalMaxPt: number
 }): { sySpent: number; ptSpent: number } {
   const {
     ticks,
@@ -403,19 +398,18 @@ function simulateAccruePrincipalForDeposit(params: {
     lowerTickKey,
     upperTickKey,
     liquidityTarget,
-    originalMaxSy,
-    originalMaxPt,
   } = params
 
   const ticksWrapper = new TicksWrapper(ticks)
   ticksWrapper.upsertBoundaryTick(lowerTickKey, snap)
   ticksWrapper.upsertBoundaryTick(upperTickKey, snap)
+  normalizeActiveTickPrincipalsBeforeDeposit(ticksWrapper, snap, lowerTickKey, upperTickKey)
   const virtualStates = new Map<number, VirtualTickState>()
 
   let totalSySpend = 0n
   let totalPtSpend = 0n
-  let pendingCrossPt: { leftKey: number; rightKey: number; ptDelta: bigint; duPart: number } | null = null
-  let pendingCrossSy: { leftKey: number; rightKey: number; syDelta: bigint; syPerL: number } | null = null
+  let pendingCrossPt: { leftKey: number; ptDelta: bigint } | null = null
+  let pendingCrossSy: { syDelta: bigint } | null = null
 
   const resolveTraversalStartKey = (candidateKey: number): number => {
     if (ticksWrapper.getTickByKey(candidateKey)) {
@@ -473,9 +467,7 @@ function simulateAccruePrincipalForDeposit(params: {
     if (isCrossing) {
       pendingCrossPt = {
         leftKey,
-        rightKey,
         ptDelta: principalPtDelta,
-        duPart: segmentLength,
       }
       return
     }
@@ -516,10 +508,7 @@ function simulateAccruePrincipalForDeposit(params: {
     const isCrossing = leftPrice < priceSplitForNeed && rightPrice > priceSplitForNeed
     if (isCrossing) {
       pendingCrossSy = {
-        leftKey,
-        rightKey,
         syDelta: principalSyDelta,
-        syPerL,
       }
       return
     }
@@ -540,15 +529,10 @@ function simulateAccruePrincipalForDeposit(params: {
   })
 
   if (pendingCrossPt && pendingCrossSy) {
-    const ptLeft = BigInt(Math.max(0, Math.floor(originalMaxPt) - Number(totalPtSpend) - GAP_TOKEN_NEEDS))
-    const syLeft = BigInt(Math.max(0, Math.floor(originalMaxSy) - Number(totalSySpend) - GAP_TOKEN_NEEDS))
-    const scaledPtIn = pendingCrossPt.ptDelta > ptLeft ? pendingCrossPt.ptDelta : ptLeft
-    const scaledSyIn = pendingCrossSy.syDelta > syLeft ? pendingCrossSy.syDelta : syLeft
-
     const minted = simulateMintSharesForTickPrestateCalcUsed({
       key: pendingCrossPt.leftKey,
-      dptIn: scaledPtIn,
-      dsyIn: scaledSyIn,
+      dptIn: pendingCrossPt.ptDelta,
+      dsyIn: pendingCrossSy.syDelta,
       ticksWrapper,
       virtualStates,
     })
@@ -569,10 +553,7 @@ function simulateAccruePrincipalForDeposit(params: {
   return { sySpent, ptSpent }
 }
 
-/**
- * Compute token needs with crossing tick adjustment
- * This matches the Rust compute_token_needs_with_crossing function
- */
+/** Compute curve-level token needs without raw crossing-tick cap scaling. */
 export function computeTokenNeedsWithCrossing(
   snap: EffSnap,
   spotPriceCurrent: number,
@@ -583,9 +564,6 @@ export function computeTokenNeedsWithCrossing(
   maxSy: number,
   maxPt: number,
   epsilonClamp: number,
-  crossingTickState: CrossingTickState,
-  crossingTickPriceLeft: number,
-  crossingTickPriceRight: number,
 ): [number, number] {
   // Below range: SY only
   if (spotPriceCurrent <= lowerPrice) {
@@ -612,62 +590,8 @@ export function computeTokenNeedsWithCrossing(
   const liquidityFromSy = maxSy / deltaCRight
 
   const liquidityTarget = Math.min(liquidityFromPt, liquidityFromSy)
-  let ptNeed = liquidityTarget * duLeft
-  let syNeed = liquidityTarget * deltaCRight
-
-  // Apply crossing tick adjustment if the tick has existing liquidity
-  // Match Rust: !crossing_tick_state.is_empty() where is_empty = (principal_share_supply == 0)
-  const isCrossingTickActive =
-    crossingTickState.principalShareSupply > 0 &&
-    crossingTickPriceLeft < spotPriceCurrent &&
-    crossingTickPriceRight > spotPriceCurrent
-
-  if (isCrossingTickActive) {
-    // Calculate PT and SY portions that would go into the crossing tick
-    // PT portion: from crossing_tick_price_left to spot_price_current (match Rust)
-    const crossingPtSegment = spotPriceCurrent - Math.max(crossingTickPriceLeft, lowerPrice)
-    const crossingPtIntended = Math.ceil(liquidityTarget * crossingPtSegment)
-
-    // SY portion: from spotPriceCurrent to crossingTickPriceRight
-    const crossingSySegmentStart = Math.max(spotPriceCurrent, crossingTickPriceLeft)
-    const crossingSySegmentEnd = Math.min(crossingTickPriceRight, upperPrice)
-    const syPerL = snap.getEffectivePrice(crossingSySegmentStart) - snap.getEffectivePrice(crossingSySegmentEnd)
-    const crossingSyIntended = Math.ceil(liquidityTarget * Math.max(syPerL, 0))
-
-    if (crossingPtIntended > 0 && crossingSyIntended > 0) {
-      // Tokens already allocated to non-crossing segments before crossing processing.
-      const ptOutsideCrossing = Math.max(ptNeed - crossingPtIntended, 0)
-      const syOutsideCrossing = Math.max(syNeed - crossingSyIntended, 0)
-
-      // Apply scaling from original max values to prevent double trimming
-      const [scaledPtIn, scaledSyIn] =
-        duLeft > 0 && deltaCRight > 0
-          ? (() => {
-              const totalPtSpend = Math.ceil(ptOutsideCrossing)
-              const totalSySpend = Math.ceil(syOutsideCrossing)
-              const ptLeft = Math.max(maxPt - totalPtSpend - GAP_TOKEN_NEEDS, 0)
-              const syLeft = Math.max(maxSy - totalSySpend - GAP_TOKEN_NEEDS, 0)
-
-              // Use max of CLMM-calculated value and scaled original value
-              return [Math.max(crossingPtIntended, ptLeft), Math.max(crossingSyIntended, syLeft)]
-            })()
-          : [crossingPtIntended, crossingSyIntended]
-
-      // Simulate add_liquidity proportional logic with scaled inputs
-      const [usedPt, usedSy] = simulateAddLiquidityProportional(
-        scaledPtIn,
-        scaledSyIn,
-        crossingTickState.principalPt,
-        crossingTickState.principalSy,
-        crossingTickState.principalShareSupply,
-      )
-
-      // Adjust needs based on what would actually be used
-      ptNeed = ptOutsideCrossing + usedPt
-
-      syNeed = syOutsideCrossing + usedSy
-    }
-  }
+  const ptNeed = liquidityTarget * duLeft
+  const syNeed = liquidityTarget * deltaCRight
 
   return [Math.ceil(syNeed), Math.ceil(ptNeed)]
 }
@@ -728,8 +652,6 @@ export function simulateAddLiquidity(marketState: MarketThreeState, args: AddLiq
     lowerTickKey: args.lowerTick,
     upperTickKey: args.upperTick,
     liquidityTarget: liquidityNeeds.liquidityTarget,
-    originalMaxSy: liquidityNeeds.originalMaxSy,
-    originalMaxPt: liquidityNeeds.originalMaxPt,
   })
 
   // Enforce budgets
@@ -750,6 +672,45 @@ export function simulateAddLiquidity(marketState: MarketThreeState, args: AddLiq
   }
 }
 
+function simulateAddLiquidityForPosition(
+  marketState: MarketThreeState,
+  args: AddLiquidityArgs,
+  existingPosition?: LpPositionCLMM,
+): AddLiquidityOutcome {
+  if (!existingPosition) {
+    return simulateAddLiquidity(marketState, args)
+  }
+
+  const budgetEffect = computeExistingPositionBudgetEffect({
+    ticks: marketState.ticks,
+    position: existingPosition,
+    userMaxSy: lamportsNumberToBigInt(args.maxSy, "user max SY"),
+    userMaxPt: lamportsNumberToBigInt(args.maxPt, "user max PT"),
+  })
+
+  const addLiquidityResult = simulateAddLiquidity(marketState, {
+    ...args,
+    maxSy: safeLamportsBigIntToNumber(budgetEffect.effectiveMaxSy, "effective max SY"),
+    maxPt: safeLamportsBigIntToNumber(budgetEffect.effectiveMaxPt, "effective max PT"),
+  })
+
+  return {
+    deltaL: addLiquidityResult.deltaL,
+    sySpent: finalizeEqualizedSpend({
+      simulatedSpend: addLiquidityResult.sySpent,
+      fixedSpent: budgetEffect.fixedSySpent,
+      fixedReleased: budgetEffect.fixedSyReleased,
+      label: "equalized SY spend",
+    }),
+    ptSpent: finalizeEqualizedSpend({
+      simulatedSpend: addLiquidityResult.ptSpent,
+      fixedSpent: budgetEffect.fixedPtSpent,
+      fixedReleased: budgetEffect.fixedPtReleased,
+      label: "equalized PT spend",
+    }),
+  }
+}
+
 /**
  * Calculate the LP tokens that will be received for a given deposit
  * This is useful for UI display and slippage calculations
@@ -813,12 +774,6 @@ export function calcDepositSyAndPtFromBaseAmount(params: {
   expirationTs: number
   currentSpotPrice: number
   syExchangeRate: number
-  /** Optional crossing tick state for accurate ratio prediction.
-   *  When provided, the prediction accounts for the existing PT/SY proportions
-   *  in the active tick, matching the on-chain behaviour more closely. */
-  crossingTickState?: CrossingTickState
-  crossingTickPriceLeft?: number
-  crossingTickPriceRight?: number
   epsilonClamp?: number
 }) {
   const {
@@ -828,9 +783,6 @@ export function calcDepositSyAndPtFromBaseAmount(params: {
     lowerPrice,
     upperPrice,
     baseTokenAmount,
-    crossingTickState = EMPTY_CROSSING_TICK_STATE,
-    crossingTickPriceLeft = 0,
-    crossingTickPriceRight = 0,
     epsilonClamp = 1e-18,
   } = params
 
@@ -848,10 +800,9 @@ export function calcDepositSyAndPtFromBaseAmount(params: {
   const priceEffUpper = effSnap.getEffectivePrice(upperPrice)
 
   // We mirror the on-chain logic in `wrapper_provide_liquidity`:
-  // 1. Use compute_token_needs_with_crossing to infer the ratio of SY/PT
-  //    the market "wants" for this price range.
-  //    When crossing tick state is provided, this accounts for the existing
-  //    PT/SY proportions in the active tick, significantly improving accuracy.
+  // 1. Use curve-level token needs to infer the SY/PT ratio for this range.
+  //    Raw active-tick proportions are ignored because the deposit CPI
+  //    normalizes the active tick before minting new shares.
   // 2. Use that ratio plus the current SY exchange rate to decide how much of the
   //    minted SY should be stripped into PT (calc_strip_amount).
   const [syMock, ptMock] = computeTokenNeedsWithCrossing(
@@ -864,9 +815,6 @@ export function calcDepositSyAndPtFromBaseAmount(params: {
     1e9,
     1e9,
     epsilonClamp,
-    crossingTickState,
-    crossingTickPriceLeft,
-    crossingTickPriceRight,
   )
 
   // Total SY the user would get by minting SY from base off-chain
@@ -922,6 +870,7 @@ function calcStripAmount(totalAmountSy: number, curSyRate: number, marketPtLiq:
  * @param lowerTick - Lower tick (APY in basis points)
  * @param upperTick - Upper tick (APY in basis points)
  * @param syExchangeRate - SY exchange rate
+ * @param options - Optional existing LP position to include fixed crossing-split equalization spend
  * @returns Simulation result with LP out, YT out, amounts spent, etc.
  */
 export function simulateWrapperProvideLiquidity(
@@ -930,6 +879,7 @@ export function simulateWrapperProvideLiquidity(
   lowerTick: number,
   upperTick: number,
   syExchangeRate: number,
+  options: AddLiquiditySimulationOptions = {},
 ): {
   lpOut: number
   ytOut: number
@@ -961,10 +911,7 @@ export function simulateWrapperProvideLiquidity(
     const priceEffLower = snap.getEffectivePrice(lowerPrice)
     const priceEffUpper = snap.getEffectivePrice(upperPrice)
 
-    // Step 3: Get crossing tick state (matches wrapper_provide_liquidity.rs)
-    const { crossingTickState, crossingTickPriceLeft, crossingTickPriceRight } = getCrossingTickStateFromTicks(ticks)
-
-    // Step 4: Calculate mock token needs using compute_token_needs_with_crossing
+    // Step 3: Calculate curve-level token needs.
     // max_sy = syAmount, max_pt = syAmount * syExchangeRate (as on-chain)
     const maxPt = syAmount * syExchangeRate
     const [syMock, ptMock] = computeTokenNeedsWithCrossing(
@@ -977,26 +924,23 @@ export function simulateWrapperProvideLiquidity(
       syAmount,
       maxPt,
       configurationOptions.epsilonClamp,
-      crossingTickState,
-      crossingTickPriceLeft,
-      crossingTickPriceRight,
     )
 
-    // Step 5: Calculate how much SY to strip (calc_strip_amount on-chain)
+    // Step 4: Calculate how much SY to strip (calc_strip_amount on-chain)
     // Cap syToStrip to syAmount to prevent negative remainder from ceil rounding
     const syToStripRaw = calcStripAmount(syAmount, syExchangeRate, ptMock, syMock)
     const syToStrip = Math.min(syToStripRaw, syAmount)
 
-    // Step 6: Calculate PT and YT from stripping
+    // Step 5: Calculate PT and YT from stripping
     // When you strip SY, you get PT = SY * syExchangeRate and YT = SY * syExchangeRate
     const ptFromStrip = syToStrip * syExchangeRate
     const ytOut = ptFromStrip // YT amount equals PT amount from strip
 
-    // Step 7: Calculate remaining SY after strip
+    // Step 6: Calculate remaining SY after strip
     // Use Math.max to ensure non-negative (safety net for floating point edge cases)
     const syRemainder = Math.max(0, syAmount - syToStrip)
 
-    // Step 8: Simulate deposit liquidity with remaining SY and PT
+    // Step 7: Simulate deposit liquidity with remaining SY and PT
     const depositResult = simulateAddLiquidity(marketState, {
       lowerTick,
       upperTick,
@@ -1037,6 +981,7 @@ export function simulateWrapperProvideLiquidity(
  * @param lowerTick - Lower tick key (APY in basis points)
  * @param upperTick - Upper tick key (APY in basis points)
  * @param syExchangeRate - SY exchange rate
+ * @param options - Optional existing LP position to include fixed crossing-split equalization spend
  * @returns Simulation result with LP out, PT to buy, SY constraint, etc.
  */
 export function simulateSwapAndSupply(
@@ -1045,6 +990,7 @@ export function simulateSwapAndSupply(
   lowerTick: number,
   upperTick: number,
   syExchangeRate: number,
+  options: AddLiquiditySimulationOptions = {},
 ): {
   lpOut: number
   ptToBuy: number
@@ -1061,7 +1007,7 @@ export function simulateSwapAndSupply(
     // So the strict SY budget for a user-provided base input is floor(base / rate).
     const syBudget = convertBaseToSyBudget(amountBase, syExchangeRate)
 
-    if (syBudget <= 0 || syBudget < MIN_SWAP_AND_SUPPLY_SY_BUDGET) {
+    if (syBudget <= 0) {
       return {
         lpOut: 0,
         ptToBuy: 0,
@@ -1143,6 +1089,7 @@ export function simulateSwapAndSupply(
         key,
         syExchangeRate,
         exactOutEstimateSlack,
+        options.existingPosition,
       )
       candidateCache.set(key, candidate)
       return candidate
@@ -1294,6 +1241,7 @@ function simulateSwapAndSupplyForPtConstraint(
   ptConstraint: number,
   syExchangeRate: number,
   exactOutEstimateSlack: number,
+  existingPosition?: LpPositionCLMM,
 ): SwapAndSupplyCandidate | null {
   let swapResult: {
     sySpent: number
@@ -1315,13 +1263,22 @@ function simulateSwapAndSupplyForPtConstraint(
   }
 
   const depositState = swapResult.postMarketState ?? marketState
-  const depositResult = simulateAddLiquidity(depositState, {
-    lowerTick,
-    upperTick,
-    maxSy: syBudget,
-    maxPt: swapResult.ptOut,
-    syExchangeRate,
-  })
+  let depositResult: AddLiquidityOutcome
+  try {
+    depositResult = simulateAddLiquidityForPosition(
+      depositState,
+      {
+        lowerTick,
+        upperTick,
+        maxSy: syBudget,
+        maxPt: swapResult.ptOut,
+        syExchangeRate,
+      },
+      existingPosition,
+    )
+  } catch {
+    return null
+  }
 
   // Swap & supply must actually add liquidity.
   // Discard candidates that end up as swap-only (deltaL == 0).