@exponent-labs/market-three-math 0.1.8

package/build/swapLegacy.js

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

package/build/swapLegacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapLegacy.js","sourceRoot":"","sources":["../src/swapLegacy.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,mCAAgF;AAChF,mCAWgB;AAEhB,MAAM,WAAW,GAAG,KAAK,CAAA;AAEzB;;;;GAIG;AACH,SAAgB,YAAY,CAAC,WAA6B,EAAE,IAAc;IACxE,MAAM,EAAE,UAAU,EAAE,oBAAoB,EAAE,KAAK,EAAE,GAAG,WAAW,CAAA;IAC/D,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAA;IAEzF,kCAAkC;IAClC,MAAM,QAAQ,GAAG,IAAI,eAAO,CAAC,IAAA,+BAAuB,EAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;IAE5F,gBAAgB;IAChB,IAAI,gBAAgB,GAAW,KAAK,CAAC,gBAAgB,CAAA;IACrD,IAAI,wBAAwB,GAAW,KAAK,CAAC,WAAW,CAAA;IAExD,2EAA2E;IAC3E,IAAI,kBAAkB,GAAW,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAA;IAC7D,IAAI,kBAAkB,GAAW,MAAM,CAAC,kBAAkB,CAAC,CAAA;IAE3D,OAAO;IACP,MAAM,SAAS,GAAG,IAAA,wBAAgB,EAAC,oBAAoB,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAA;IACxF,MAAM,cAAc,GAAW,oBAAoB,CAAC,cAAc,CAAA;IAElE,qBAAqB;IACrB,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACtC,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAa,CAAC,MAAM,EAAE,CAAC;YAC5C,IAAI,IAAI,CAAC,cAAc,GAAG,gBAAgB,EAAE,CAAC;gBAC3C,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAA;YACpF,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,CAAC,cAAc,GAAG,gBAAgB,EAAE,CAAC;gBAC3C,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAA;YACpF,CAAC;QACH,CAAC;IACH,CAAC;IAED,eAAe;IACf,IAAI,YAAY,GAAW,CAAC,CAAA;IAC5B,IAAI,QAAQ,GAAW,CAAC,CAAA;IACxB,IAAI,cAAc,GAAW,CAAC,CAAA;IAC9B,IAAI,YAAY,GAAW,IAAI,CAAC,QAAQ,CAAA;IAExC,wCAAwC;IACxC,IAAI,UAAU,GAAW,CAAC,CAAA;IAC1B,MAAM,aAAa,GAAW,IAAI,CAAA;IAElC,OAAO,YAAY,GAAG,CAAC,IAAI,UAAU,GAAG,aAAa,EAAE,CAAC;QACtD,UAAU,EAAE,CAAA;QAEZ,yCAAyC;QACzC,MAAM,qBAAqB,GAAG,IAAA,2BAAmB,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;QAElF,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;YACnC,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAa,CAAC,MAAM,EAAE,CAAC;gBAC5C,iCAAiC;gBACjC,MAAM,WAAW,GAAG,IAAA,6BAAqB,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBAC1E,IAAI,WAAW,KAAK,IAAI;oBAAE,MAAK;gBAE/B,gDAAgD;gBAChD,gBAAgB,GAAG,IAAA,sBAAc,EAAC,wBAAwB,CAAC,CAAA,CAAC,0BAA0B;gBACtF,wBAAwB,GAAG,WAAW,CAAA,CAAC,oBAAoB;gBAE3D,mEAAmE;gBACnE,MAAM,YAAY,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,WAAW,CAAC,CAAA;gBACtD,IAAI,YAAY,EAAE,CAAC;oBACjB,kBAAkB,GAAG,IAAA,iBAAS,EAAC,EAAE,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;oBACvF,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;gBACjD,CAAC;gBACD,SAAQ;YACV,CAAC;iBAAM,CAAC;gBACN,8BAA8B;gBAC9B,MAAK;YACP,CAAC;QACH,CAAC;QAED,MAAM,kBAAkB,GAAG,qBAAqB,CAAA;QAEhD,4CAA4C;QAC5C,MAAM,WAAW,GAAW,IAAA,sBAAc,EAAC,wBAAwB,CAAC,CAAA;QACpE,MAAM,YAAY,GAAW,IAAA,sBAAc,EAAC,kBAAkB,CAAC,CAAA;QAE/D,kCAAkC;QAClC,MAAM,OAAO,GAAW,QAAQ,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAA;QAEpE,yCAAyC;QACzC,MAAM,eAAe,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;QACtE,MAAM,WAAW,GAAW,eAAe,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE,CAAA;QACnE,MAAM,WAAW,GAAW,eAAe,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE,CAAA;QAEnE,MAAM,GAAG,GAAW,oBAAoB,CAAC,YAAY,CAAA;QAErD,gEAAgE;QAChE,0CAA0C;QAC1C,MAAM,cAAc,GAAW,QAAQ,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAA;QACvE,MAAM,eAAe,GAAW,CAAC,MAAM,CAAC,kBAAkB,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,GAAG,cAAc,CAAC,CAAA;QAC/G,MAAM,OAAO,GAAW,eAAe,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAE/F,MAAM,QAAQ,GAAW,gBAAgB,GAAG,WAAW,CAAA;QACvD,MAAM,YAAY,GAAW,MAAM,CAAC,kBAAkB,CAAC,GAAG,QAAQ,CAAA;QAClE,MAAM,OAAO,GAAW,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;QAEjF,MAAM,KAAK,GAAW,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAA;QACrD,MAAM,SAAS,GAAW,MAAM,CAAC,kBAAkB,CAAC,GAAG,KAAK,CAAA;QAE5D,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAa,CAAC,MAAM,EAAE,CAAC;YAC5C,oCAAoC;YACpC,MAAM,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;YAC9D,MAAM,YAAY,GAAG,YAAY,GAAG,gBAAgB,CAAA;YACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,YAAY,CAAC,CAAA;YAElD,IAAI,YAAY,IAAI,GAAG,EAAE,CAAC;gBACxB,iBAAiB;gBACjB,MAAM,YAAY,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,kBAAkB,CAAC,CAAA;gBAC7D,IAAI,YAAY,EAAE,CAAC;oBACjB,kBAAkB,IAAI,YAAY,CAAC,IAAI,CAAC,YAAY,CAAA;oBACpD,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;gBACjD,CAAC;gBACD,wBAAwB,GAAG,kBAAkB,CAAA;gBAC7C,gBAAgB,GAAG,YAAY,CAAA;gBAC/B,SAAQ;YACV,CAAC;YAED,+BAA+B;YAC/B,MAAM,WAAW,GAAW,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAA;YAC5D,MAAM,UAAU,GAAW,gBAAgB,GAAG,QAAQ,CAAA;YACtD,MAAM,OAAO,GAAW,QAAQ,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAA;YAC9D,MAAM,UAAU,GAAW,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC,CAAA;YAC9F,MAAM,iBAAiB,GAAW,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAA;YAE3E,IAAI,iBAAiB,GAAG,CAAC,EAAE,CAAC;gBAC1B,MAAM,WAAW,GAAW,IAAA,wBAAgB,EAAC,iBAAiB,EAAE,SAAS,CAAC,CAAA;gBAC1E,MAAM,cAAc,GAAW,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,GAAG,cAAc,CAAC,GAAG,WAAW,CAAC,CAAA;gBACvF,MAAM,QAAQ,GAAW,WAAW,GAAG,cAAc,CAAA;gBACrD,MAAM,QAAQ,GAAW,iBAAiB,GAAG,WAAW,CAAA;gBAExD,YAAY,IAAI,QAAQ,CAAA;gBACxB,QAAQ,IAAI,QAAQ,CAAA;gBACpB,cAAc,IAAI,cAAc,CAAA;YAClC,CAAC;YAED,YAAY,IAAI,WAAW,CAAA;YAC3B,gBAAgB,GAAG,UAAU,CAAA;QAC/B,CAAC;aAAM,CAAC;YACN,oCAAoC;YACpC,MAAM,QAAQ,GAAW,QAAQ,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAA;YAChE,MAAM,aAAa,GAAW,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;YAClG,MAAM,oBAAoB,GAAW,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAA;YACpE,MAAM,YAAY,GAAW,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAA;YAE1E,IAAI,oBAAoB,IAAI,GAAG,EAAE,CAAC;gBAChC,6BAA6B;gBAC7B,MAAM,WAAW,GAAG,IAAA,6BAAqB,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBAC1E,IAAI,WAAW,KAAK,IAAI;oBAAE,MAAK;gBAE/B,0BAA0B;gBAC1B,MAAM,YAAY,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBACnE,IAAI,YAAY,EAAE,CAAC;oBACjB,kBAAkB,GAAG,IAAA,iBAAS,EAAC,EAAE,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;oBACvF,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;gBACjD,CAAC;gBAED,gBAAgB,GAAG,IAAA,sBAAc,EAAC,wBAAwB,CAAC,CAAA;gBAC3D,wBAAwB,GAAG,WAAW,CAAA;gBACtC,SAAQ;YACV,CAAC;YAED,wDAAwD;YACxD,MAAM,OAAO,GAAW,OAAO,GAAG,YAAY,CAAA;YAC9C,MAAM,YAAY,GAAW,QAAQ,CAAC,2BAA2B,CAAC,OAAO,CAAC,CAAA;YAE1E,cAAc;YACd,MAAM,YAAY,GAAW,CAAC,SAAS,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,CAAA;YACpF,MAAM,KAAK,GAAW,gBAAgB,GAAG,YAAY,CAAA;YACrD,MAAM,WAAW,GAAW,SAAS,GAAG,KAAK,CAAA;YAE7C,wCAAwC;YACxC,MAAM,aAAa,GAAW,IAAA,iBAAS,EAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,WAAW,CAAC,CAAA;YACrF,MAAM,cAAc,GAAW,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAA;YAE/D,IAAI,aAAa,KAAK,EAAE,EAAE,CAAC;gBACzB,mCAAmC;gBACnC,MAAM,WAAW,GAAG,IAAA,6BAAqB,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBAC1E,IAAI,WAAW,KAAK,IAAI;oBAAE,MAAK;gBAE/B,0BAA0B;gBAC1B,MAAM,YAAY,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBACnE,IAAI,YAAY,EAAE,CAAC;oBACjB,kBAAkB,GAAG,IAAA,iBAAS,EAAC,EAAE,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;oBACvF,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;gBACjD,CAAC;gBAED,gBAAgB,GAAG,IAAA,sBAAc,EAAC,wBAAwB,CAAC,CAAA;gBAC3D,wBAAwB,GAAG,WAAW,CAAA;gBACtC,SAAQ;YACV,CAAC;YAED,yBAAyB;YACzB,MAAM,WAAW,GAAG,IAAA,wBAAgB,EAAC,MAAM,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,CAAA;YACtE,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,GAAG,cAAc,CAAC,GAAG,WAAW,CAAC,CAAA;YAC/E,MAAM,QAAQ,GAAG,WAAW,GAAG,cAAc,CAAA;YAC7C,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,CAAC,GAAG,WAAW,CAAA;YAEpD,qBAAqB;YACrB,YAAY,IAAI,QAAQ,CAAA;YACxB,QAAQ,IAAI,QAAQ,CAAA;YACpB,cAAc,IAAI,cAAc,CAAA;YAEhC,kCAAkC;YAClC,YAAY,IAAI,MAAM,CAAC,cAAc,CAAC,CAAA;YACtC,gBAAgB,GAAG,YAAY,CAAA;YAE/B,4BAA4B;YAC5B,IAAI,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,WAAW,CAAC,IAAI,GAAG,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;gBACxE,MAAM,WAAW,GAAG,IAAA,6BAAqB,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBAC1E,IAAI,WAAW,KAAK,IAAI;oBAAE,MAAK;gBAE/B,0BAA0B;gBAC1B,MAAM,YAAY,GAAG,IAAA,qBAAa,EAAC,KAAK,EAAE,wBAAwB,CAAC,CAAA;gBACnE,IAAI,YAAY,EAAE,CAAC;oBACjB,kBAAkB,GAAG,IAAA,iBAAS,EAAC,EAAE,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;oBACvF,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;gBACjD,CAAC;gBAED,gBAAgB,GAAG,IAAA,sBAAc,EAAC,wBAAwB,CAAC,CAAA;gBAC3D,wBAAwB,GAAG,WAAW,CAAA;YACxC,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO;QACL,gBAAgB,EAAE,IAAI,CAAC,QAAQ,GAAG,YAAY;QAC9C,SAAS,EAAE,YAAY;QACvB,oBAAoB,EAAE,QAAQ;QAC9B,0BAA0B,EAAE,cAAc;QAC1C,cAAc,EAAE,gBAAgB;QAChC,cAAc,EAAE,wBAAwB;KACzC,CAAA;AACH,CAAC;AAzOD,oCAyOC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,WAA6B,EAAE,QAAgB,EAAE,SAAwB;IACpG,OAAO,YAAY,CAAC,WAAW,EAAE;QAC/B,SAAS;QACT,QAAQ;QACR,cAAc,EAAE,WAAW,CAAC,qBAAqB;QACjD,kBAAkB,EAAE,KAAK;KAC1B,CAAC,CAAA;AACJ,CAAC;AAPD,oCAOC"}

package/build/swapV2.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLMM Swap simulation V2
+ * Closely mirrors the Rust on-chain implementation from swap.rs
+ * Uses TicksWrapper to simulate RB-tree behavior
+ */
+import { MarketThreeState, SwapArgs, SwapOutcomeV2 } from "./types";
+/**
+ * Simulate a swap on the CLMM market (V2 - mirrors Rust closely)
+ * This is a pure function that does not mutate the market state
+ */
+export declare function simulateSwap(marketState: MarketThreeState, args: SwapArgs): SwapOutcomeV2;

package/build/swapV2.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateSwap = void 0;
+/**
+ * CLMM Swap simulation V2
+ * Closely mirrors the Rust on-chain implementation from swap.rs
+ * Uses TicksWrapper to simulate RB-tree behavior
+ */
+const types_1 = require("./types");
+const utilsV2_1 = require("./utilsV2");
+const BASE_POINTS = 10000;
+/**
+ * Simulate a swap on the CLMM market (V2 - mirrors Rust closely)
+ * This is a pure function that does not mutate the market state
+ */
+function simulateSwap(marketState, args) {
+    const DEBUG = false; // Set to true for debugging
+    const { financials, configurationOptions, ticks } = marketState;
+    const secondsRemaining = Math.max(0, Number(financials.expirationTs) - Date.now() / 1000);
+    // 0) Snapshot of effective price parameters
+    const snapshot = new utilsV2_1.EffSnap((0, utilsV2_1.normalizedTimeRemaining)(secondsRemaining), args.syExchangeRate);
+    // Wrap ticks for RB-tree-like operations
+    const ticksWrapper = new utilsV2_1.TicksWrapper(ticks);
+    // Current state in both spot and anchor coordinates
+    let currentPriceSpot = ticksWrapper.currentSpotPrice;
+    let currentLeftBoundaryKey = ticksWrapper.currentTickKey;
+    // Active liquidity at current interval (prefix-sum at left boundary)
+    let activeLiquidityU64 = ticksWrapper.currentPrefixSum;
+    let activeLiquidityF64 = Number(activeLiquidityU64);
+    // Fees
+    const lpFeeRate = (0, utilsV2_1.calculateFeeRate)(configurationOptions.lnFeeRateRoot, secondsRemaining);
+    const protocolFeeBps = configurationOptions.treasuryFeeBps;
+    const eps = configurationOptions.epsilonClamp;
+    // Limits (optional spot)
+    if (args.priceSpotLimit !== undefined) {
+        if (args.direction === types_1.SwapDirection.PtToSy) {
+            if (args.priceSpotLimit < currentPriceSpot) {
+                throw new Error("Price limit violated: limit must be >= current price for PtToSy");
+            }
+        }
+        else {
+            if (args.priceSpotLimit > currentPriceSpot) {
+                throw new Error("Price limit violated: limit must be <= current price for SyToPt");
+            }
+        }
+    }
+    // Accumulators
+    let amountOutNetU64 = 0;
+    let feeLpOutU64 = 0;
+    let feeProtocolOutU64 = 0;
+    let amountInLeft = args.amountIn;
+    if (DEBUG) {
+        console.log(`\nSwapV2 Debug: direction=${args.direction}, amountIn=${args.amountIn}`);
+        console.log(`Initial: currentTickKey=${currentLeftBoundaryKey}, spotPrice=${currentPriceSpot}, activeLiq=${activeLiquidityU64}`);
+    }
+    // Main loop across contiguous intervals while we have input left
+    // Rust: while amount_in_left > 1
+    let iterations = 0;
+    const MAX_ITERATIONS = 30;
+    while (amountInLeft > 1 && iterations < MAX_ITERATIONS) {
+        iterations++;
+        if (DEBUG) {
+            console.log(`\n--- Iteration ${iterations}, amountInLeft=${amountInLeft} ---`);
+        }
+        // Right boundary of current interval (must exist to have a half-open [left, right))
+        const rightBoundaryKeyOpt = ticksWrapper.successorKey(currentLeftBoundaryKey);
+        if (DEBUG) {
+            console.log(`rightBoundaryKey=${rightBoundaryKeyOpt}`);
+        }
+        // Handle case when no right boundary exists
+        if (rightBoundaryKeyOpt === null) {
+            if (args.direction === types_1.SwapDirection.SyToPt) {
+                // Cross boundary to the left (no right boundary means we need to go left)
+                const crossed = crossOneBoundary(ticksWrapper, types_1.SwapDirection.SyToPt, currentLeftBoundaryKey, {
+                    currentLeftBoundaryKey,
+                    currentPriceSpot,
+                    activeLiquidityU64,
+                    activeLiquidityF64,
+                });
+                if (!crossed)
+                    break;
+                currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+                currentPriceSpot = crossed.currentPriceSpot;
+                activeLiquidityU64 = crossed.activeLiquidityU64;
+                activeLiquidityF64 = crossed.activeLiquidityF64;
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+        const rightBoundaryKey = rightBoundaryKeyOpt;
+        // Interval anchors (spot prices at boundaries)
+        const anchorULeft = ticksWrapper.getSpotPrice(currentLeftBoundaryKey);
+        const anchorURight = ticksWrapper.getSpotPrice(rightBoundaryKey);
+        // Effective price at current spot
+        const cEffOld = snapshot.getEffectivePrice(currentPriceSpot);
+        // Load principal ledgers for the interval (stored on the left boundary)
+        const { principalPt, principalSy } = ticksWrapper.getPrincipals(currentLeftBoundaryKey);
+        // Y_max = L * (C(u_old) - C(u_right))
+        const cEffAtBoundary = snapshot.getEffectivePrice(anchorURight);
+        const yMaxToBoundaryF = activeLiquidityF64 * (cEffOld - cEffAtBoundary);
+        // PT_max_left = L * (u_old - u_left)
+        const duToLeft = currentPriceSpot - anchorULeft;
+        const ptMaxToLeftF = activeLiquidityF64 * duToLeft;
+        // Validate y_max and pt_max values before using them
+        if (!Number.isFinite(yMaxToBoundaryF) ||
+            !Number.isFinite(ptMaxToLeftF) ||
+            yMaxToBoundaryF < 0 ||
+            ptMaxToLeftF < 0) {
+            const crossed = crossOneBoundary(ticksWrapper, args.direction, args.direction === types_1.SwapDirection.PtToSy ? rightBoundaryKey : currentLeftBoundaryKey, {
+                currentLeftBoundaryKey,
+                currentPriceSpot,
+                activeLiquidityU64,
+                activeLiquidityF64,
+            });
+            if (!crossed)
+                break;
+            currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+            currentPriceSpot = crossed.currentPriceSpot;
+            activeLiquidityU64 = crossed.activeLiquidityU64;
+            activeLiquidityF64 = crossed.activeLiquidityF64;
+            continue;
+        }
+        // kappa_sy = principal_sy / y_max (with proper edge case handling)
+        // Matches Rust logic: if max <= eps and principal == 0, constraint is not binding (1.0)
+        let kappaSy;
+        if (yMaxToBoundaryF > eps) {
+            kappaSy = Number(principalSy) / yMaxToBoundaryF;
+        }
+        else if (principalSy === 0n) {
+            kappaSy = 1.0; // No constraint since nothing to provide
+        }
+        else {
+            kappaSy = Infinity; // Has principal but can't use it
+        }
+        // kappa_pt = principal_pt / pt_max_left (with proper edge case handling)
+        // Matches Rust logic: if max <= eps and principal == 0, constraint is not binding (1.0)
+        let kappaPt;
+        if (ptMaxToLeftF > eps) {
+            kappaPt = Number(principalPt) / ptMaxToLeftF;
+        }
+        else if (principalPt === 0n) {
+            kappaPt = 1.0; // No constraint since nothing to provide
+        }
+        else {
+            kappaPt = Infinity; // Has principal but can't use it
+        }
+        // kappa = min(kappa_pt, kappa_sy, 1.0) -- MUST be clamped to 1.0
+        const kappa = Math.min(kappaPt, kappaSy, 1.0);
+        if (DEBUG) {
+            console.log(`  anchorULeft=${anchorULeft}, anchorURight=${anchorURight}`);
+            console.log(`  principalPt=${principalPt}, principalSy=${principalSy}`);
+            console.log(`  kappaPt=${kappaPt}, kappaSy=${kappaSy}, kappa=${kappa}`);
+        }
+        // Check kappa validity - if invalid or zero, cross boundary
+        if (!Number.isFinite(kappa) || kappa <= 0) {
+            const crossed = crossOneBoundary(ticksWrapper, args.direction, args.direction === types_1.SwapDirection.PtToSy ? rightBoundaryKey : currentLeftBoundaryKey, {
+                currentLeftBoundaryKey,
+                currentPriceSpot,
+                activeLiquidityU64,
+                activeLiquidityF64,
+            });
+            if (!crossed)
+                break;
+            currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+            currentPriceSpot = crossed.currentPriceSpot;
+            activeLiquidityU64 = crossed.activeLiquidityU64;
+            activeLiquidityF64 = crossed.activeLiquidityF64;
+            continue;
+        }
+        const lTradeF64 = activeLiquidityF64 * kappa;
+        // Check l_trade validity
+        if (!Number.isFinite(lTradeF64) || lTradeF64 <= eps) {
+            const crossed = crossOneBoundary(ticksWrapper, args.direction, args.direction === types_1.SwapDirection.PtToSy ? rightBoundaryKey : currentLeftBoundaryKey, {
+                currentLeftBoundaryKey,
+                currentPriceSpot,
+                activeLiquidityU64,
+                activeLiquidityF64,
+            });
+            if (!crossed)
+                break;
+            currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+            currentPriceSpot = crossed.currentPriceSpot;
+            activeLiquidityU64 = crossed.activeLiquidityU64;
+            activeLiquidityF64 = crossed.activeLiquidityF64;
+            continue;
+        }
+        if (args.direction === types_1.SwapDirection.PtToSy) {
+            // PT -> SY swap
+            // Final du in this interval
+            const duByInput = amountInLeft / lTradeF64;
+            const duToBoundary = anchorURight - currentPriceSpot;
+            const duActual = Math.min(duByInput, duToBoundary);
+            if (DEBUG) {
+                console.log(`  PtToSy: duByInput=${duByInput}, duToBoundary=${duToBoundary}, duActual=${duActual}`);
+                console.log(`  lTradeF64=${lTradeF64}, kappa=${kappa}`);
+            }
+            // Check if we need to cross boundary first (at boundary)
+            if (duToBoundary <= eps) {
+                // Cross boundary to unlock the next interval
+                const crossed = crossOneBoundary(ticksWrapper, types_1.SwapDirection.PtToSy, rightBoundaryKey, {
+                    currentLeftBoundaryKey,
+                    currentPriceSpot,
+                    activeLiquidityU64,
+                    activeLiquidityF64,
+                });
+                if (!crossed)
+                    break;
+                currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+                currentPriceSpot = crossed.currentPriceSpot;
+                activeLiquidityU64 = crossed.activeLiquidityU64;
+                activeLiquidityF64 = crossed.activeLiquidityF64;
+                continue;
+            }
+            // Token flows for this segment (ceil for input to protect pool)
+            const ptInSegment = Math.ceil(lTradeF64 * duActual);
+            const anchorUNew = currentPriceSpot + duActual;
+            const cEffNew = snapshot.getEffectivePrice(anchorUNew);
+            const syOutGrossF = lTradeF64 * (cEffOld - cEffNew);
+            // Clamp by SY principal
+            let syOutGrossU64 = Math.floor(syOutGrossF);
+            syOutGrossU64 = Math.min(syOutGrossU64, Number(principalSy));
+            if (DEBUG) {
+                console.log(`  ptInSegment=${ptInSegment}, syOutGrossU64=${syOutGrossU64}`);
+            }
+            // 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) {
+                let totalFeeOut;
+                if (args.isCurrentFlashSwap) {
+                    const syOutBase = syOutGrossU64 * args.syExchangeRate;
+                    const ytValueBase = ptInSegment - syOutBase;
+                    const ytValueSy = ytValueBase / args.syExchangeRate;
+                    totalFeeOut = (0, utilsV2_1.getFeeFromAmount)(Math.max(0, Math.floor(ytValueSy)), lpFeeRate);
+                }
+                else {
+                    totalFeeOut = (0, utilsV2_1.getFeeFromAmount)(syOutGrossU64, lpFeeRate);
+                }
+                const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS);
+                const lpFeeOut = totalFeeOut - protocolFeeOut;
+                const syOutNet = syOutGrossU64 - totalFeeOut;
+                // Accumulate to user
+                amountOutNetU64 += syOutNet;
+                feeLpOutU64 += lpFeeOut;
+                feeProtocolOutU64 += protocolFeeOut;
+                // Consume input and advance state
+                amountInLeft -= ptInSegment;
+                currentPriceSpot = anchorUNew;
+            }
+            // If we hit boundary, cross
+            if (anchorURight - currentPriceSpot <= eps && amountInLeft > 0) {
+                const crossed = crossOneBoundary(ticksWrapper, types_1.SwapDirection.PtToSy, rightBoundaryKey, {
+                    currentLeftBoundaryKey,
+                    currentPriceSpot,
+                    activeLiquidityU64,
+                    activeLiquidityF64,
+                });
+                if (!crossed)
+                    break;
+                currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+                currentPriceSpot = crossed.currentPriceSpot;
+                activeLiquidityU64 = crossed.activeLiquidityU64;
+                activeLiquidityF64 = crossed.activeLiquidityF64;
+            }
+        }
+        else {
+            // SY -> PT swap
+            const cEffLeft = snapshot.getEffectivePrice(anchorULeft);
+            // Final ΔC in this interval
+            const deltaCByInput = amountInLeft / lTradeF64;
+            const deltaCToLeftBoundary = cEffLeft - cEffOld;
+            const deltaCActual = Math.min(deltaCByInput, deltaCToLeftBoundary);
+            if (DEBUG) {
+                console.log(`  SyToPt: deltaCByInput=${deltaCByInput}, deltaCToLeftBoundary=${deltaCToLeftBoundary}, deltaCActual=${deltaCActual}`);
+                console.log(`  lTradeF64=${lTradeF64}, kappa=${kappa}, eps=${eps}`);
+            }
+            // Check if we need to cross boundary first (at boundary)
+            if (deltaCToLeftBoundary <= eps) {
+                // Cross boundary to the left
+                const crossed = crossOneBoundary(ticksWrapper, types_1.SwapDirection.SyToPt, currentLeftBoundaryKey, {
+                    currentLeftBoundaryKey,
+                    currentPriceSpot,
+                    activeLiquidityU64,
+                    activeLiquidityF64,
+                });
+                if (!crossed)
+                    break;
+                currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+                currentPriceSpot = crossed.currentPriceSpot;
+                activeLiquidityU64 = crossed.activeLiquidityU64;
+                activeLiquidityF64 = crossed.activeLiquidityF64;
+                continue;
+            }
+            // New effective price and spot after consuming ΔC
+            const cEffNew = cEffOld + deltaCActual;
+            const spotPriceNew = snapshot.spotPriceFromEffectivePrice(cEffNew);
+            // Token flows
+            const syInSegmentF = lTradeF64 * (cEffNew - cEffOld);
+            const duAbs = currentPriceSpot - spotPriceNew;
+            const ptOutGrossF = lTradeF64 * duAbs;
+            // Clamp gross PT by available principal
+            let ptOutGrossU64 = Math.floor(ptOutGrossF);
+            ptOutGrossU64 = Math.min(ptOutGrossU64, Number(principalPt));
+            // ceil for input to protect pool
+            const syInSegmentU64 = Math.ceil(syInSegmentF);
+            if (DEBUG) {
+                console.log(`  spotPriceNew=${spotPriceNew}, duAbs=${duAbs}`);
+                console.log(`  ptOutGrossU64=${ptOutGrossU64}, syInSegmentU64=${syInSegmentU64}`);
+            }
+            if (ptOutGrossU64 > 0) {
+                // Fees in token_out (PT)
+                // For flash swaps, fee is based on YT value = pt - sy × sy_exchange_rate
+                let totalFeeOut;
+                if (args.isCurrentFlashSwap) {
+                    const syInBase = syInSegmentU64 * args.syExchangeRate;
+                    const ytValue = ptOutGrossU64 - syInBase;
+                    totalFeeOut = (0, utilsV2_1.getFeeFromAmount)(Math.max(0, Math.floor(ytValue)), lpFeeRate);
+                }
+                else {
+                    totalFeeOut = (0, utilsV2_1.getFeeFromAmount)(ptOutGrossU64, lpFeeRate);
+                }
+                const protocolFeeOut = Math.floor((totalFeeOut * protocolFeeBps) / BASE_POINTS);
+                const lpFeeOut = totalFeeOut - protocolFeeOut;
+                const ptOutNet = ptOutGrossU64 - totalFeeOut;
+                // Accumulate to user
+                amountOutNetU64 += ptOutNet;
+                feeLpOutU64 += lpFeeOut;
+                feeProtocolOutU64 += protocolFeeOut;
+            }
+            // Consume input and advance state
+            amountInLeft -= syInSegmentU64;
+            currentPriceSpot = spotPriceNew;
+            // If we hit boundary, cross
+            // Use effective price difference for consistency with pre-swap epsilon check
+            if (Math.abs(cEffNew - cEffLeft) <= eps && amountInLeft > 0) {
+                const crossed = crossOneBoundary(ticksWrapper, types_1.SwapDirection.SyToPt, currentLeftBoundaryKey, {
+                    currentLeftBoundaryKey,
+                    currentPriceSpot,
+                    activeLiquidityU64,
+                    activeLiquidityF64,
+                });
+                if (!crossed)
+                    break;
+                currentLeftBoundaryKey = crossed.currentLeftBoundaryKey;
+                currentPriceSpot = crossed.currentPriceSpot;
+                activeLiquidityU64 = crossed.activeLiquidityU64;
+                activeLiquidityF64 = crossed.activeLiquidityF64;
+            }
+        }
+    }
+    return {
+        amountInConsumed: args.amountIn - amountInLeft,
+        amountOut: amountOutNetU64,
+        lpFeeChargedOutToken: feeLpOutU64,
+        protocolFeeChargedOutToken: feeProtocolOutU64,
+        finalSpotPrice: currentPriceSpot,
+        finalTickKey: currentLeftBoundaryKey, // This is now the key, not array index
+    };
+}
+exports.simulateSwap = simulateSwap;
+/**
+ * Cross one boundary and update core state
+ * Mirrors Rust's cross_one_boundary_and_update_core
+ */
+function crossOneBoundary(ticksWrapper, direction, boundaryKeyToCross, state) {
+    // Get liquidity_net at the boundary we're crossing
+    const deltaNetI64 = ticksWrapper.getLiquidityNet(boundaryKeyToCross);
+    const lOldI64 = state.activeLiquidityU64;
+    // Update active liquidity
+    let lNewI64;
+    if (direction === types_1.SwapDirection.PtToSy) {
+        // Crossing upward boundary: add liquidity_net
+        lNewI64 = lOldI64 + deltaNetI64;
+    }
+    else {
+        // Crossing downward boundary: subtract liquidity_net
+        lNewI64 = lOldI64 - deltaNetI64;
+    }
+    // Ensure non-negative
+    if (lNewI64 < 0n) {
+        lNewI64 = 0n;
+    }
+    // Move spot to the boundary we cross
+    const boundarySpot = ticksWrapper.getSpotPrice(boundaryKeyToCross);
+    // Advance current left boundary key
+    let newLeftBoundaryKey;
+    if (direction === types_1.SwapDirection.PtToSy) {
+        // Moving right: new left boundary is the crossed boundary
+        newLeftBoundaryKey = boundaryKeyToCross;
+    }
+    else {
+        // Moving left: new left boundary is predecessor of current
+        newLeftBoundaryKey = ticksWrapper.predecessorKey(state.currentLeftBoundaryKey);
+    }
+    if (newLeftBoundaryKey === null) {
+        return null; // End of range
+    }
+    return {
+        currentLeftBoundaryKey: newLeftBoundaryKey,
+        currentPriceSpot: boundarySpot,
+        activeLiquidityU64: lNewI64,
+        activeLiquidityF64: Number(lNewI64),
+    };
+}
+//# sourceMappingURL=swapV2.js.map