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

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.9.18
+
+- Version bump only for package @exponent-labs/market-three-math
+
 ## 0.1.0
 
 - Initial release

package/build/addLiquidity.d.ts

@@ -2,46 +2,19 @@
  * CLMM Add Liquidity simulation
  * Ported from exponent_clmm/src/state/market_three/helpers/add_liquidity.rs
  */
-import { Ticks } from "@exponent-labs/exponent-fetcher";
-import { AddLiquidityArgs, AddLiquidityOutcome, CrossingScaleParams, CrossingTickState, LiquidityNeeds, MarketThreeState } from "./types";
+import type { LpPositionCLMM } from "@exponent-labs/exponent-fetcher";
+import { AddLiquidityArgs, AddLiquidityOutcome, LiquidityNeeds, MarketThreeState } from "./types";
 import { EffSnap } from "./utilsV2";
-/**
- * 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 declare function getCrossingTickStateFromTicks(ticks: Ticks): {
-    crossingTickState: CrossingTickState;
-    crossingTickPriceLeft: number;
-    crossingTickPriceRight: number;
+type AddLiquiditySimulationOptions = {
+    existingPosition?: LpPositionCLMM;
 };
 /**
  * Compute liquidity target and token needs based on position range and budgets
  * Ported from compute_liquidity_target_and_token_needs in math.rs
  */
 export declare function computeLiquidityTargetAndTokenNeeds(snap: EffSnap, spotPriceCurrent: number, priceEffLower: number, priceEffUpper: number, lowerPrice: number, upperPrice: number, lowerTickIdx: number, upperTickIdx: number, currentIndex: number, maxSy: number, maxPt: number, epsilonClamp: number): LiquidityNeeds;
-/**
- * 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 declare function scaleCrossingTickInputs(scaleParams: CrossingScaleParams, duPtPart: number, syPerL1: number, clmmPtDelta: number, clmmSyDelta: number): [number, number];
-/**
- * Compute token needs with crossing tick adjustment
- * This matches the Rust compute_token_needs_with_crossing function
- */
-export declare function computeTokenNeedsWithCrossing(snap: EffSnap, spotPriceCurrent: number, priceEffLower: number, priceEffUpper: number, lowerPrice: number, upperPrice: number, maxSy: number, maxPt: number, epsilonClamp: number, crossingTickState: CrossingTickState, crossingTickPriceLeft: number, crossingTickPriceRight: number): [number, number];
+/** Compute curve-level token needs without raw crossing-tick cap scaling. */
+export declare function computeTokenNeedsWithCrossing(snap: EffSnap, spotPriceCurrent: number, priceEffLower: number, priceEffUpper: number, lowerPrice: number, upperPrice: number, maxSy: number, maxPt: number, epsilonClamp: number): [number, number];
 /**
  * Simulate adding liquidity to the CLMM market
  * This is a pure function that does not mutate the market state
@@ -69,12 +42,6 @@ export declare 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;
 }): {
     syNeeded: number;
@@ -94,9 +61,10 @@ export declare function calcDepositSyAndPtFromBaseAmount(params: {
  * @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 declare function simulateWrapperProvideLiquidity(marketState: MarketThreeState, amountBase: number, lowerTick: number, upperTick: number, syExchangeRate: number): {
+export declare function simulateWrapperProvideLiquidity(marketState: MarketThreeState, amountBase: number, lowerTick: number, upperTick: number, syExchangeRate: number, options?: AddLiquiditySimulationOptions): {
     lpOut: number;
     ytOut: number;
     syToStrip: number;
@@ -118,9 +86,10 @@ export declare function simulateWrapperProvideLiquidity(marketState: MarketThree
  * @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 declare function simulateSwapAndSupply(marketState: MarketThreeState, amountBase: number, lowerTick: number, upperTick: number, syExchangeRate: number): {
+export declare function simulateSwapAndSupply(marketState: MarketThreeState, amountBase: number, lowerTick: number, upperTick: number, syExchangeRate: number, options?: AddLiquiditySimulationOptions): {
     lpOut: number;
     ptToBuy: number;
     syConstraint: number;
@@ -130,3 +99,4 @@ export declare function simulateSwapAndSupply(marketState: MarketThreeState, amo
     syDeposited: number;
     ptDeposited: number;
 } | null;
+export {};

package/build/addLiquidity.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCrossingTickStateFromTicks = getCrossingTickStateFromTicks;
 exports.computeLiquidityTargetAndTokenNeeds = computeLiquidityTargetAndTokenNeeds;
-exports.scaleCrossingTickInputs = scaleCrossingTickInputs;
 exports.computeTokenNeedsWithCrossing = computeTokenNeedsWithCrossing;
 exports.simulateAddLiquidity = simulateAddLiquidity;
 exports.calculateLpOut = calculateLpOut;
@@ -10,9 +8,9 @@ exports.estimateBalancedDeposit = estimateBalancedDeposit;
 exports.calcDepositSyAndPtFromBaseAmount = calcDepositSyAndPtFromBaseAmount;
 exports.simulateWrapperProvideLiquidity = simulateWrapperProvideLiquidity;
 exports.simulateSwapAndSupply = simulateSwapAndSupply;
+const existingPositionEqualization_1 = require("./existingPositionEqualization");
 const swapV2_1 = require("./swapV2");
 const types_1 = require("./types");
-const utils_1 = require("./utils");
 const utilsV2_1 = require("./utilsV2");
 const TICK_KEY_BASE_POINTS = 1_000_000;
 // Keep this in sync with exponent_clmm's add_liquidity helper so off-chain
@@ -21,44 +19,13 @@ 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 = {
-    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.
- */
-function getCrossingTickStateFromTicks(ticks) {
-    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 = (0, utils_1.getSuccessorTickKey)(ticks, currentTickNode.apyBasePoints);
-    const successorTick = successorKey != null ? (0, utils_1.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,
-    };
-}
+const ZERO_BIGINT = 0n;
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
 /**
  * Compute liquidity target and token needs based on position range and budgets
  * Ported from compute_liquidity_target_and_token_needs in math.rs
@@ -78,11 +45,6 @@ function computeLiquidityTargetAndTokenNeeds(snap, spotPriceCurrent, priceEffLow
             ptNeeded: 0,
             priceSplitForNeed: lowerPrice,
             priceSplitTickIdx: lowerTickIdx,
-            // No crossing possible when below range
-            originalMaxSy: maxSy,
-            originalMaxPt: maxPt,
-            duLeftTotal: 0,
-            deltaCRightTotal: deltaCTotal,
         };
     }
     else if (spotPriceCurrent >= upperPrice) {
@@ -97,11 +59,6 @@ function computeLiquidityTargetAndTokenNeeds(snap, spotPriceCurrent, priceEffLow
             ptNeeded: Math.floor(ptNeed),
             priceSplitForNeed: upperPrice,
             priceSplitTickIdx: upperTickIdx,
-            // No crossing possible when above range
-            originalMaxSy: maxSy,
-            originalMaxPt: maxPt,
-            duLeftTotal: duTotal,
-            deltaCRightTotal: 0,
         };
     }
     else {
@@ -120,75 +77,29 @@ function computeLiquidityTargetAndTokenNeeds(snap, spotPriceCurrent, priceEffLow
             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
- */
-function scaleCrossingTickInputs(scaleParams, duPtPart, syPerL1, clmmPtDelta, clmmSyDelta) {
-    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);
-        // 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)];
-    }
-    // Fallback to original logic if no crossing scale params
-    return [clmmPtDelta, clmmSyDelta];
+function toU64BigInt(value) {
+    return BigInt(Math.max(0, Math.floor(value)));
 }
-/**
- * Simulate the proportional add_liquidity logic
- * Returns [usedPt, usedSy] based on existing tick proportions
- */
-function simulateAddLiquidityProportional(intentPt, intentSy, marketTotalPt, marketTotalSy, marketTotalLp) {
-    if (marketTotalLp === 0 || marketTotalPt === 0 || marketTotalSy === 0) {
-        // Empty tick - use all intended amounts
-        return [intentPt, intentSy];
-    }
-    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];
+function lamportsNumberToBigInt(value, label) {
+    const lamports = Math.max(0, Math.floor(value));
+    if (!Number.isSafeInteger(lamports)) {
+        throw new Error(`${label} exceeds JS safe integer range: ${value}`);
     }
-    else {
-        // SY is the limiting factor
-        const lpTokensOut = lpFromSy;
-        const usedSy = intentSy;
-        const usedPt = Math.ceil((marketTotalPt * lpTokensOut) / marketTotalLp);
-        return [usedPt, usedSy];
+    return BigInt(lamports);
+}
+function safeLamportsBigIntToNumber(value, label) {
+    if (value < ZERO_BIGINT || value > MAX_SAFE_INTEGER_BIGINT) {
+        throw new Error(`${label} exceeds JS safe integer range: ${value.toString()}`);
     }
+    return Number(value);
 }
-function toU64BigInt(value) {
-    return BigInt(Math.max(0, Math.floor(value)));
+function finalizeEqualizedSpend(params) {
+    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, denominator) {
     if (denominator <= 0n) {
@@ -223,6 +134,78 @@ function getVirtualTickState(key, ticksWrapper, virtualStates) {
     virtualStates.set(key, state);
     return state;
 }
+function ceilNormalizedPrincipal(value, cap) {
+    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) {
+    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, snap, lowerTickKey, upperTickKey) {
+    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) {
     const { key, dptIn, dsyIn, ticksWrapper, virtualStates } = params;
     const state = getVirtualTickState(key, ticksWrapper, virtualStates);
@@ -310,10 +293,11 @@ function simulateMintSharesForTickPrestateCalcUsed(params) {
     return { minted, usedPt, usedSy };
 }
 function simulateAccruePrincipalForDeposit(params) {
-    const { ticks, snap, lowerPrice, upperPrice, priceSplitForNeed, splitTickKey, lowerTickKey, upperTickKey, liquidityTarget, originalMaxSy, originalMaxPt, } = params;
+    const { ticks, snap, lowerPrice, upperPrice, priceSplitForNeed, splitTickKey, lowerTickKey, upperTickKey, liquidityTarget, } = params;
     const ticksWrapper = new utilsV2_1.TicksWrapper(ticks);
     ticksWrapper.upsertBoundaryTick(lowerTickKey, snap);
     ticksWrapper.upsertBoundaryTick(upperTickKey, snap);
+    normalizeActiveTickPrincipalsBeforeDeposit(ticksWrapper, snap, lowerTickKey, upperTickKey);
     const virtualStates = new Map();
     let totalSySpend = 0n;
     let totalPtSpend = 0n;
@@ -363,9 +347,7 @@ function simulateAccruePrincipalForDeposit(params) {
         if (isCrossing) {
             pendingCrossPt = {
                 leftKey,
-                rightKey,
                 ptDelta: principalPtDelta,
-                duPart: segmentLength,
             };
             return;
         }
@@ -400,10 +382,7 @@ function simulateAccruePrincipalForDeposit(params) {
         const isCrossing = leftPrice < priceSplitForNeed && rightPrice > priceSplitForNeed;
         if (isCrossing) {
             pendingCrossSy = {
-                leftKey,
-                rightKey,
                 syDelta: principalSyDelta,
-                syPerL,
             };
             return;
         }
@@ -421,14 +400,10 @@ function simulateAccruePrincipalForDeposit(params) {
         totalSySpend += minted.usedSy;
     });
     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,
         });
@@ -445,11 +420,8 @@ function simulateAccruePrincipalForDeposit(params) {
     }
     return { sySpent, ptSpent };
 }
-/**
- * Compute token needs with crossing tick adjustment
- * This matches the Rust compute_token_needs_with_crossing function
- */
-function computeTokenNeedsWithCrossing(snap, spotPriceCurrent, priceEffLower, priceEffUpper, lowerPrice, upperPrice, maxSy, maxPt, epsilonClamp, crossingTickState, crossingTickPriceLeft, crossingTickPriceRight) {
+/** Compute curve-level token needs without raw crossing-tick cap scaling. */
+function computeTokenNeedsWithCrossing(snap, spotPriceCurrent, priceEffLower, priceEffUpper, lowerPrice, upperPrice, maxSy, maxPt, epsilonClamp) {
     // Below range: SY only
     if (spotPriceCurrent <= lowerPrice) {
         const deltaCTotal = priceEffLower - priceEffUpper;
@@ -471,45 +443,8 @@ function computeTokenNeedsWithCrossing(snap, spotPriceCurrent, priceEffLower, pr
     const liquidityFromPt = maxPt / duLeft;
     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)];
 }
 /**
@@ -546,8 +481,6 @@ function simulateAddLiquidity(marketState, args) {
         lowerTickKey: args.lowerTick,
         upperTickKey: args.upperTick,
         liquidityTarget: liquidityNeeds.liquidityTarget,
-        originalMaxSy: liquidityNeeds.originalMaxSy,
-        originalMaxPt: liquidityNeeds.originalMaxPt,
     });
     // Enforce budgets
     const sySpent = syNeededWithCrossing;
@@ -564,6 +497,37 @@ function simulateAddLiquidity(marketState, args) {
         ptSpent,
     };
 }
+function simulateAddLiquidityForPosition(marketState, args, existingPosition) {
+    if (!existingPosition) {
+        return simulateAddLiquidity(marketState, args);
+    }
+    const budgetEffect = (0, existingPositionEqualization_1.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
@@ -611,7 +575,7 @@ function estimateBalancedDeposit(marketState, targetLiquidity, lowerTickApy, upp
 /** Calculate SY and PT needed to deposit into liquidity pool from base token amount */
 /** Off-chain analogue of on-chain wrapper_provide_liquidity function */
 function calcDepositSyAndPtFromBaseAmount(params) {
-    const { expirationTs, currentSpotPrice, syExchangeRate, lowerPrice, upperPrice, baseTokenAmount, crossingTickState = EMPTY_CROSSING_TICK_STATE, crossingTickPriceLeft = 0, crossingTickPriceRight = 0, epsilonClamp = 1e-18, } = params;
+    const { expirationTs, currentSpotPrice, syExchangeRate, lowerPrice, upperPrice, baseTokenAmount, epsilonClamp = 1e-18, } = params;
     if (baseTokenAmount <= 0 || syExchangeRate <= 0) {
         return {
             syNeeded: 0,
@@ -623,13 +587,12 @@ function calcDepositSyAndPtFromBaseAmount(params) {
     const priceEffLower = effSnap.getEffectivePrice(lowerPrice);
     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(effSnap, currentSpotPrice, priceEffLower, priceEffUpper, lowerPrice, upperPrice, 1e9, 1e9, epsilonClamp, crossingTickState, crossingTickPriceLeft, crossingTickPriceRight);
+    const [syMock, ptMock] = computeTokenNeedsWithCrossing(effSnap, currentSpotPrice, priceEffLower, priceEffUpper, lowerPrice, upperPrice, 1e9, 1e9, epsilonClamp);
     // Total SY the user would get by minting SY from base off-chain
     // (we approximate on-chain `mint_sy_return_data.sy_out_amount`).
     const syAmount = Math.floor(baseTokenAmount * syExchangeRate);
@@ -679,9 +642,10 @@ function calcStripAmount(totalAmountSy, curSyRate, marketPtLiq, marketSyLiq) {
  * @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.
  */
-function simulateWrapperProvideLiquidity(marketState, amountBase, lowerTick, upperTick, syExchangeRate) {
+function simulateWrapperProvideLiquidity(marketState, amountBase, lowerTick, upperTick, syExchangeRate, options = {}) {
     try {
         const { financials, configurationOptions, ticks } = marketState;
         const secondsRemaining = Math.max(0, Number(financials.expirationTs) - Date.now() / 1000);
@@ -698,24 +662,22 @@ function simulateWrapperProvideLiquidity(marketState, amountBase, lowerTick, upp
         // Precompute effective prices
         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(snap, currentSpot, priceEffLower, priceEffUpper, lowerPrice, upperPrice, syAmount, maxPt, configurationOptions.epsilonClamp, crossingTickState, crossingTickPriceLeft, crossingTickPriceRight);
-        // Step 5: Calculate how much SY to strip (calc_strip_amount on-chain)
+        const [syMock, ptMock] = computeTokenNeedsWithCrossing(snap, currentSpot, priceEffLower, priceEffUpper, lowerPrice, upperPrice, syAmount, maxPt, configurationOptions.epsilonClamp);
+        // 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,
@@ -754,15 +716,16 @@ function simulateWrapperProvideLiquidity(marketState, amountBase, lowerTick, upp
  * @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.
  */
-function simulateSwapAndSupply(marketState, amountBase, lowerTick, upperTick, syExchangeRate) {
+function simulateSwapAndSupply(marketState, amountBase, lowerTick, upperTick, syExchangeRate, options = {}) {
     try {
         // 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, syExchangeRate);
-        if (syBudget <= 0 || syBudget < MIN_SWAP_AND_SUPPLY_SY_BUDGET) {
+        if (syBudget <= 0) {
             return {
                 lpOut: 0,
                 ptToBuy: 0,
@@ -831,7 +794,7 @@ function simulateSwapAndSupply(marketState, amountBase, lowerTick, upperTick, sy
             if (cached !== undefined) {
                 return cached;
             }
-            const candidate = simulateSwapAndSupplyForPtConstraint(marketState, lowerTick, upperTick, syBudget, key, syExchangeRate, exactOutEstimateSlack);
+            const candidate = simulateSwapAndSupplyForPtConstraint(marketState, lowerTick, upperTick, syBudget, key, syExchangeRate, exactOutEstimateSlack, options.existingPosition);
             candidateCache.set(key, candidate);
             return candidate;
         };
@@ -951,7 +914,7 @@ function simulateSwapAndSupply(marketState, amountBase, lowerTick, upperTick, sy
         return null;
     }
 }
-function simulateSwapAndSupplyForPtConstraint(marketState, lowerTick, upperTick, syBudget, ptConstraint, syExchangeRate, exactOutEstimateSlack) {
+function simulateSwapAndSupplyForPtConstraint(marketState, lowerTick, upperTick, syBudget, ptConstraint, syExchangeRate, exactOutEstimateSlack, existingPosition) {
     let swapResult;
     try {
         swapResult = simulateBuyPtExactOutWrapper(marketState, syBudget, ptConstraint, syExchangeRate, exactOutEstimateSlack);
@@ -961,13 +924,19 @@ function simulateSwapAndSupplyForPtConstraint(marketState, lowerTick, upperTick,
         return null;
     }
     const depositState = swapResult.postMarketState ?? marketState;
-    const depositResult = simulateAddLiquidity(depositState, {
-        lowerTick,
-        upperTick,
-        maxSy: syBudget,
-        maxPt: swapResult.ptOut,
-        syExchangeRate,
-    });
+    let depositResult;
+    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).
     if (depositResult.deltaL <= 0) {