@hawksightco/hawk-sdk 1.3.265 → 1.3.266

package/dist/meteora/liquidityStrategy.js

@@ -0,0 +1,1325 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyType = void 0;
+exports.chunkHybridDepositParameters = chunkHybridDepositParameters;
+exports.getQPriceFromId = getQPriceFromId;
+exports.buildSpotStrategyParameters = buildSpotStrategyParameters;
+exports.resetUninvolvedLiquidityParams = resetUninvolvedLiquidityParams;
+exports.getAmountXForBin = getAmountXForBin;
+exports.getAmountYForBin = getAmountYForBin;
+exports.calculateChunkAmounts = calculateChunkAmounts;
+exports.buildCurveStrategyParameters = buildCurveStrategyParameters;
+exports.buildBidAskStrategyParameters = buildBidAskStrategyParameters;
+exports.buildStrategyParameters = buildStrategyParameters;
+exports.distributionToStrategyType = distributionToStrategyType;
+exports.distributionToHybridStrategy = distributionToHybridStrategy;
+exports.buildHybridStrategyParameters = buildHybridStrategyParameters;
+exports.chunkBinRange = chunkBinRange;
+exports.buildBitFlagAndNegateStrategyParameters = buildBitFlagAndNegateStrategyParameters;
+exports.toAmountIntoBins = toAmountIntoBins;
+exports.chunkDepositParameters = chunkDepositParameters;
+exports.chunkBinRangeWithInitialSize = chunkBinRangeWithInitialSize;
+exports.chunkDepositParametersWithInitialSize = chunkDepositParametersWithInitialSize;
+const bn_js_1 = __importDefault(require("bn.js"));
+/**
+ * Liquidity strategy types matching Meteora DLMM SDK.
+ */
+var StrategyType;
+(function (StrategyType) {
+    /** Uniform distribution - equal value per bin (adjusted for price) */
+    StrategyType[StrategyType["SPOT"] = 0] = "SPOT";
+    /** Curve distribution - decreasing amounts away from active bin */
+    StrategyType[StrategyType["CURVE"] = 1] = "CURVE";
+    /** Bid-Ask distribution - increasing amounts away from active bin */
+    StrategyType[StrategyType["BID_ASK"] = 2] = "BID_ASK";
+})(StrategyType || (exports.StrategyType = StrategyType = {}));
+/**
+ * Scale offset used for fixed-point arithmetic in price calculations.
+ * Matches DLMM SDK's SCALE_OFFSET = 64
+ */
+const SCALE_OFFSET = 64;
+/**
+ * Constants for Q64.64 fixed-point math (matching Meteora SDK)
+ */
+const ONE = new bn_js_1.default(1).shln(SCALE_OFFSET);
+const MAX = new bn_js_1.default(2).pow(new bn_js_1.default(128)).sub(new bn_js_1.default(1));
+const MAX_EXPONENTIAL = new bn_js_1.default(0x80000);
+const BASIS_POINT_MAX = 10000;
+/**
+ * Binary exponentiation for Q64.64 fixed-point numbers.
+ * Matches Meteora SDK's pow function from u64xu64_math.ts
+ *
+ * @param base - Base value in Q64.64 format
+ * @param exp - Exponent (can be negative)
+ * @returns base^exp in Q64.64 format
+ */
+function pow(base, exp) {
+    let invert = exp.isNeg();
+    if (exp.isZero()) {
+        return ONE;
+    }
+    exp = invert ? exp.abs() : exp;
+    if (exp.gt(MAX_EXPONENTIAL)) {
+        return new bn_js_1.default(0);
+    }
+    let squaredBase = base;
+    let result = ONE;
+    // For base >= 1, invert first for better precision
+    if (squaredBase.gte(result)) {
+        squaredBase = MAX.div(squaredBase);
+        invert = !invert;
+    }
+    if (!exp.and(new bn_js_1.default(0x1)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x2)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x4)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x8)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x10)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x20)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x40)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x80)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x100)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x200)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x400)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x800)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x1000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x2000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x4000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x8000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x10000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x20000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+    if (!exp.and(new bn_js_1.default(0x40000)).isZero()) {
+        result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+    }
+    if (result.isZero()) {
+        return new bn_js_1.default(0);
+    }
+    if (invert) {
+        result = MAX.div(result);
+    }
+    return result;
+}
+/**
+ * Chunks hybrid deposit parameters across a bin range.
+ *
+ * For each chunk of the bin range, applies resetUninvolvedLiquidityParams to each
+ * layer and calculates the per-chunk amounts per layer via toAmountIntoBins.
+ *
+ * @param layerResults - Array of HybridStrategyResult from distributionToHybridStrategy
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId) for the full position
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId) for the full position
+ * @param activeId - Current active bin ID
+ * @param binStep - Bin step in basis points
+ * @param chunkSize - Maximum bins per chunk
+ * @param favorXInActiveBin - Whether X is favored in the active bin
+ * @returns Array of chunked hybrid deposit parameters, one entry per chunk
+ */
+function chunkHybridDepositParameters(layerResults, minDeltaId, maxDeltaId, activeId, binStep, chunkSize, favorXInActiveBin = false) {
+    const lowerBinId = activeId.add(minDeltaId).toNumber();
+    const upperBinId = activeId.add(maxDeltaId).toNumber();
+    const chunks = chunkBinRange(lowerBinId, upperBinId, chunkSize);
+    const result = [];
+    for (const chunk of chunks) {
+        const chunkMinDeltaId = new bn_js_1.default(chunk.lowerBinId).sub(activeId);
+        const chunkMaxDeltaId = new bn_js_1.default(chunk.upperBinId).sub(activeId);
+        const layers = [];
+        for (const layer of layerResults) {
+            // Reset uninvolved params for this chunk (zeros out X or Y if chunk is one-sided)
+            const chunkParams = resetUninvolvedLiquidityParams(chunkMinDeltaId, chunkMaxDeltaId, favorXInActiveBin, { x0: layer.x0, y0: layer.y0, deltaX: layer.deltaX, deltaY: layer.deltaY });
+            // Calculate per-bin amounts for this chunk
+            const binsAmounts = toAmountIntoBins(activeId, chunkMinDeltaId, chunkMaxDeltaId, chunkParams.deltaX, chunkParams.deltaY, chunkParams.x0, chunkParams.y0, binStep, favorXInActiveBin);
+            const { totalXAmount, totalYAmount } = binsAmounts.reduce((acc, bin) => ({
+                totalXAmount: acc.totalXAmount.add(bin.amountX),
+                totalYAmount: acc.totalYAmount.add(bin.amountY),
+            }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+            layers.push({
+                params: chunkParams,
+                maxAmountX: totalXAmount,
+                maxAmountY: totalYAmount,
+            });
+        }
+        result.push({
+            lowerBinId: chunk.lowerBinId,
+            upperBinId: chunk.upperBinId,
+            minDeltaId: chunkMinDeltaId,
+            maxDeltaId: chunkMaxDeltaId,
+            layers,
+        });
+    }
+    return result;
+}
+/**
+ * Calculates the Q-price base factor: (1 + binStep/10000) in Q64.64 format.
+ * This represents the price multiplier between adjacent bins.
+ *
+ * @param binStep - The bin step in basis points (e.g., 100 = 1%)
+ * @returns Base factor in Q64.64 fixed-point format
+ */
+function getQPriceBaseFactor(binStep) {
+    const bps = binStep.shln(SCALE_OFFSET).div(new bn_js_1.default(BASIS_POINT_MAX));
+    return ONE.add(bps);
+}
+/**
+ * Calculates the Q-price from a bin ID.
+ * Price = (1 + binStep/10000)^binId in Q64.64 format.
+ *
+ * Uses binary exponentiation matching Meteora SDK for precision.
+ *
+ * @param binId - The bin ID (can be negative)
+ * @param binStep - The bin step in basis points
+ * @returns Price in Q64.64 fixed-point format
+ */
+function getQPriceFromId(binId, binStep) {
+    return pow(getQPriceBaseFactor(binStep), binId);
+}
+/**
+ * Calculates the sum of price weights for bins on the ask side (above active bin).
+ *
+ * For SPOT strategy, amount in each bin = x0 * price_weight
+ * where price_weight = (1 + binStep/10000)^(-(activeId + deltaId))
+ *
+ * Total amount = x0 * sum(price_weights)
+ * Therefore: x0 = totalAmount / sum(price_weights)
+ *
+ * @param activeId - The active bin ID
+ * @param minDeltaId - Minimum delta ID (relative to active bin)
+ * @param maxDeltaId - Maximum delta ID (relative to active bin)
+ * @param binStep - The bin step in basis points
+ * @returns Sum of price weights in Q64.64 format
+ */
+function getSumOfPriceWeights(activeId, minDeltaId, maxDeltaId, binStep) {
+    let totalWeight = new bn_js_1.default(0);
+    const baseFactor = getQPriceBaseFactor(binStep);
+    const minBinId = activeId.add(minDeltaId);
+    const maxBinId = activeId.add(maxDeltaId);
+    // Start from maxBinId and iterate down
+    // price = (1 + binStep/10000)^(-binId)
+    // We start with the price at -maxBinId and multiply by baseFactor as binId decreases
+    let currentPrice = getQPriceFromId(maxBinId.neg(), binStep);
+    for (let binId = maxBinId.toNumber(); binId >= minBinId.toNumber(); binId--) {
+        totalWeight = totalWeight.add(currentPrice);
+        // Moving to lower binId means multiplying price by baseFactor
+        currentPrice = currentPrice.mul(baseFactor).shrn(SCALE_OFFSET);
+    }
+    return totalWeight;
+}
+/**
+ * Finds x0 for SPOT strategy on the ask side (bins above active bin).
+ *
+ * For SPOT strategy with deltaX = 0:
+ * - Each bin gets: amountX = x0 * price_weight
+ * - Total amount = x0 * sum(price_weights)
+ * - Therefore: x0 = totalAmount / sum(price_weights)
+ *
+ * @param amountX - Total X amount to distribute
+ * @param minDeltaId - Minimum delta ID (relative to active bin), must be >= 0 for ask side
+ * @param maxDeltaId - Maximum delta ID (relative to active bin)
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @returns x0 value for the strategy
+ */
+function findX0ForSpot(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountX.isZero() || amountX.isNeg()) {
+        return new bn_js_1.default(0);
+    }
+    const totalWeight = getSumOfPriceWeights(activeId, minDeltaId, maxDeltaId, binStep);
+    if (totalWeight.isZero()) {
+        return new bn_js_1.default(0);
+    }
+    // x0 = amountX / totalWeight (in Q64.64)
+    // x0 = (amountX << 64) / totalWeight
+    return amountX.shln(SCALE_OFFSET).div(totalWeight);
+}
+/**
+ * Finds y0 for SPOT strategy on the bid side (bins below active bin).
+ *
+ * For SPOT strategy with deltaY = 0:
+ * - Each bin gets: amountY = y0 (constant per bin)
+ * - Total amount = y0 * num_bins
+ * - Therefore: y0 = totalAmount / num_bins
+ *
+ * @param amountY - Total Y amount to distribute
+ * @param minDeltaId - Minimum delta ID (relative to active bin), must be < 0 for bid side
+ * @param maxDeltaId - Maximum delta ID (relative to active bin)
+ * @returns y0 value for the strategy
+ */
+function findY0ForSpot(amountY, minDeltaId, maxDeltaId) {
+    if (minDeltaId.gt(maxDeltaId) || amountY.isZero() || amountY.isNeg()) {
+        return new bn_js_1.default(0);
+    }
+    // Number of bins = maxDeltaId - minDeltaId + 1
+    const numBins = maxDeltaId.sub(minDeltaId).addn(1);
+    if (numBins.isZero()) {
+        return new bn_js_1.default(0);
+    }
+    // y0 = amountY / numBins
+    return amountY.div(numBins);
+}
+/**
+ * Builds liquidity strategy parameters for SPOT (uniform) distribution.
+ *
+ * This function calculates x0 and y0 values that will distribute the given amounts
+ * uniformly across the specified bin range when used with the rebalanceLiquidity instruction.
+ *
+ * The function handles three cases:
+ * 1. Position entirely below active bin (bid side only) → only Y deposited
+ * 2. Position entirely above active bin (ask side only) → only X deposited
+ * 3. Position spans active bin → both X and Y deposited
+ *
+ * @param amountX - Total X amount to deposit
+ * @param amountY - Total Y amount to deposit
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId)
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId)
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @param favorXInActiveId - Whether X is favored in the active bin (affects bid/ask boundary)
+ * @returns Strategy parameters { x0, y0, deltaX, deltaY }
+ */
+function buildSpotStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId = false) {
+    // Invalid range
+    if (minDeltaId.gt(maxDeltaId)) {
+        return {
+            x0: new bn_js_1.default(0),
+            y0: new bn_js_1.default(0),
+            deltaX: new bn_js_1.default(0),
+            deltaY: new bn_js_1.default(0),
+        };
+    }
+    // Determine bid/ask boundary based on favorXInActiveId
+    // - If favorXInActiveId = true: active bin is ask side (X), bid side ends at deltaId = -1
+    // - If favorXInActiveId = false: active bin is bid side (Y), ask side starts at deltaId = 1
+    const bidSideEndDeltaId = favorXInActiveId ? new bn_js_1.default(-1) : new bn_js_1.default(0);
+    const askSideStartDeltaId = favorXInActiveId ? new bn_js_1.default(0) : new bn_js_1.default(1);
+    // Case 1: Position entirely on bid side (below active bin) - Y only
+    const depositOnlyY = maxDeltaId.lte(bidSideEndDeltaId);
+    // Case 2: Position entirely on ask side (above active bin) - X only
+    const depositOnlyX = minDeltaId.gte(askSideStartDeltaId);
+    if (depositOnlyY) {
+        // Only Y token - all bins are on bid side
+        const y0 = findY0ForSpot(amountY, minDeltaId, maxDeltaId);
+        return {
+            x0: new bn_js_1.default(0),
+            y0,
+            deltaX: new bn_js_1.default(0),
+            deltaY: new bn_js_1.default(0),
+        };
+    }
+    if (depositOnlyX) {
+        // Only X token - all bins are on ask side
+        const x0 = findX0ForSpot(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+        return {
+            x0,
+            y0: new bn_js_1.default(0),
+            deltaX: new bn_js_1.default(0),
+            deltaY: new bn_js_1.default(0),
+        };
+    }
+    // Case 3: Position spans active bin - both X and Y
+    // Y goes to bid side bins (minDeltaId to bidSideEndDeltaId)
+    // X goes to ask side bins (askSideStartDeltaId to maxDeltaId)
+    const y0 = findY0ForSpot(amountY, minDeltaId, bidSideEndDeltaId);
+    const x0 = findX0ForSpot(amountX, askSideStartDeltaId, maxDeltaId, binStep, activeId);
+    return {
+        x0,
+        y0,
+        deltaX: new bn_js_1.default(0),
+        deltaY: new bn_js_1.default(0),
+    };
+}
+/**
+ * Resets strategy parameters for a chunk that may not span the full position range.
+ *
+ * When splitting a position into chunks, each chunk may only cover part of the range:
+ * - If chunk is entirely on bid side → zero out X parameters
+ * - If chunk is entirely on ask side → zero out Y parameters
+ * - If chunk spans active bin → keep both X and Y parameters
+ *
+ * @param minDeltaId - Chunk's minimum delta ID
+ * @param maxDeltaId - Chunk's maximum delta ID
+ * @param favorXInActiveId - Whether X is favored in the active bin
+ * @param params - Original strategy parameters from buildSpotStrategyParameters
+ * @returns Adjusted parameters for the chunk
+ */
+function resetUninvolvedLiquidityParams(minDeltaId, maxDeltaId, favorXInActiveId, params) {
+    const bidSideEndDeltaId = favorXInActiveId ? new bn_js_1.default(-1) : new bn_js_1.default(0);
+    const askSideStartDeltaId = bidSideEndDeltaId.addn(1);
+    let { x0, y0, deltaX, deltaY } = params;
+    // If chunk is entirely on bid side (maxDeltaId <= bidSideEndDeltaId) → zero out X
+    if (maxDeltaId.lte(bidSideEndDeltaId)) {
+        x0 = new bn_js_1.default(0);
+        deltaX = new bn_js_1.default(0);
+    }
+    // If chunk is entirely on ask side (minDeltaId >= askSideStartDeltaId) → zero out Y
+    if (minDeltaId.gte(askSideStartDeltaId)) {
+        y0 = new bn_js_1.default(0);
+        deltaY = new bn_js_1.default(0);
+    }
+    return { x0, y0, deltaX, deltaY };
+}
+/**
+ * Calculates the actual X amount that will be deposited into a bin on the ask side.
+ *
+ * For SPOT strategy: amountX = x0 * price_weight
+ * where price_weight = (1 + binStep/10000)^(-(activeId + deltaId))
+ *
+ * @param x0 - Base X amount from strategy parameters
+ * @param deltaId - Delta ID relative to active bin
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @returns Amount of X for this bin
+ */
+function getAmountXForBin(x0, deltaId, binStep, activeId) {
+    if (x0.isZero()) {
+        return new bn_js_1.default(0);
+    }
+    const binId = activeId.add(deltaId);
+    const priceWeight = getQPriceFromId(binId.neg(), binStep);
+    // amountX = x0 * priceWeight >> 64
+    return x0.mul(priceWeight).shrn(SCALE_OFFSET);
+}
+/**
+ * Calculates the actual Y amount that will be deposited into a bin on the bid side.
+ *
+ * For SPOT strategy: amountY = y0 (constant per bin)
+ *
+ * @param y0 - Base Y amount from strategy parameters
+ * @returns Amount of Y for this bin
+ */
+function getAmountYForBin(y0) {
+    return y0;
+}
+/**
+ * Calculates total X and Y amounts for a chunk based on strategy parameters.
+ *
+ * This iterates through each bin in the chunk and sums up the amounts.
+ *
+ * @param activeId - The active bin ID
+ * @param minDeltaId - Chunk's minimum delta ID
+ * @param maxDeltaId - Chunk's maximum delta ID
+ * @param params - Strategy parameters (after resetUninvolvedLiquidityParams)
+ * @param binStep - The bin step in basis points
+ * @param favorXInActiveId - Whether X is favored in the active bin
+ * @returns Total X and Y amounts for the chunk
+ */
+function calculateChunkAmounts(activeId, minDeltaId, maxDeltaId, params, binStep, favorXInActiveId) {
+    const { x0, y0 } = params;
+    const bidSideEndDeltaId = favorXInActiveId ? -1 : 0;
+    const askSideStartDeltaId = bidSideEndDeltaId + 1;
+    let totalXAmount = new bn_js_1.default(0);
+    let totalYAmount = new bn_js_1.default(0);
+    for (let deltaId = minDeltaId.toNumber(); deltaId <= maxDeltaId.toNumber(); deltaId++) {
+        if (deltaId <= bidSideEndDeltaId) {
+            // Bid side - Y token
+            totalYAmount = totalYAmount.add(y0);
+        }
+        else {
+            // Ask side - X token
+            const amountX = getAmountXForBin(x0, new bn_js_1.default(deltaId), binStep, activeId);
+            totalXAmount = totalXAmount.add(amountX);
+        }
+    }
+    return { totalXAmount, totalYAmount };
+}
+// =============================================================================
+// CURVE STRATEGY
+// =============================================================================
+/**
+ * Finds base y0 for CURVE strategy.
+ *
+ * CURVE strategy has liquidity concentrated near active bin, decreasing away from it.
+ * Formula: amountY = y0 + deltaY * m where m = distance from active bin
+ * Setting deltaY = -y0 / (m1 + 1) gives decreasing amounts.
+ *
+ * @param amountY - Total Y amount to distribute
+ * @param minDeltaId - Minimum delta ID (negative for bid side)
+ * @param maxDeltaId - Maximum delta ID (negative for bid side)
+ * @returns Base y0 value
+ */
+function findBaseY0ForCurve(amountY, minDeltaId, maxDeltaId) {
+    if (minDeltaId.gt(maxDeltaId) || amountY.lte(new bn_js_1.default(0))) {
+        return new bn_js_1.default(0);
+    }
+    if (minDeltaId.eq(maxDeltaId)) {
+        return amountY;
+    }
+    // m1 = -minDeltaId, m2 = -maxDeltaId (distances from active bin)
+    const m1 = minDeltaId.neg();
+    const m2 = maxDeltaId.neg();
+    // sum(amounts) = y0 * (m1-m2+1) + deltaY * (m1*(m1+1)/2 - m2*(m2-1)/2)
+    // set deltaY = -y0 / (m1 + 1)
+    // A = (m1-m2+1) - (m1*(m1+1)/2 - m2*(m2-1)/2) / (m1+1)
+    // y0 = amountY / A
+    const b = m1.sub(m2).addn(1);
+    const c = m1.mul(m1.addn(1)).divn(2);
+    const d = m2.mul(m2.subn(1)).divn(2);
+    const a = b.sub(c.sub(d).div(m1.addn(1)));
+    if (a.isZero()) {
+        return amountY;
+    }
+    return amountY.div(a);
+}
+/**
+ * Finds y0 and deltaY for CURVE strategy with iterative refinement.
+ *
+ * @param amountY - Total Y amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param activeId - Active bin ID
+ * @returns { base: y0, delta: deltaY }
+ */
+function findY0AndDeltaYForCurve(amountY, minDeltaId, maxDeltaId, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
+        return { base: new bn_js_1.default(0), delta: new bn_js_1.default(0) };
+    }
+    let baseY0 = findBaseY0ForCurve(amountY, minDeltaId, maxDeltaId);
+    const m1 = minDeltaId.neg();
+    // deltaY = -y0 / (m1 + 1)
+    const deltaY = baseY0.neg().div(m1.addn(1));
+    // Iterative refinement to ensure we don't exceed amountY
+    while (true) {
+        const totalAmountY = calculateBidSideAmount(activeId, minDeltaId, maxDeltaId, deltaY, baseY0);
+        if (totalAmountY.gt(amountY)) {
+            baseY0 = baseY0.subn(1);
+        }
+        else {
+            return { base: baseY0, delta: deltaY };
+        }
+    }
+}
+/**
+ * Finds x0 and deltaX for CURVE strategy that produces linear decrease from active bin.
+ *
+ * For CURVE, we want the ask side to linearly decrease away from the active bin,
+ * mirroring the bid side's behavior.
+ *
+ * The on-chain formula for ask side is:
+ *   amountX = (x0 + deltaX * delta) * priceWeight
+ *
+ * For linear decrease in baseAmount (x0 + deltaX * delta):
+ *   - At minDelta: baseAmount = x0 + deltaX * minDelta (highest)
+ *   - At maxDelta: baseAmount approaches 0
+ *
+ * Using deltaX = -x0 / (maxDelta + 1) gives:
+ *   - At delta=0: baseAmount = x0 (would be highest, but minDelta >= 1)
+ *   - At delta=maxDelta+1: baseAmount = 0
+ *
+ * The final amountX will be approximately linear because the decreasing baseAmount
+ * partially compensates for the exponentially decaying priceWeight.
+ *
+ * @param amountX - Total X amount to distribute
+ * @param minDeltaId - Minimum delta ID (should be >= 1 for ask side)
+ * @param maxDeltaId - Maximum delta ID
+ * @param binStep - Bin step in basis points
+ * @param activeId - Active bin ID
+ * @returns { x0, deltaX } parameters
+ */
+function findX0AndDeltaXForCurveMirrored(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountX.lte(new bn_js_1.default(0))) {
+        return { base: new bn_js_1.default(0), delta: new bn_js_1.default(0) };
+    }
+    const numBins = maxDeltaId.sub(minDeltaId).addn(1).toNumber();
+    if (numBins === 1) {
+        // Single bin: just use x0 directly
+        const priceWeight = getQPriceFromId(activeId.add(minDeltaId).neg(), binStep);
+        const x0 = amountX.shln(SCALE_OFFSET).div(priceWeight);
+        return { base: x0, delta: new bn_js_1.default(0) };
+    }
+    // Meteora's approach:
+    // deltaX = -x0 / maxDelta
+    // x0 = amountX * 2^64 / (B - C)
+    // where:
+    //   B = sum of priceWeights: p(m1) + p(m1+1) + ... + p(m2)
+    //   C = weighted sum / m2: (m1*p(m1) + ... + m2*p(m2)) / m2
+    const m1 = minDeltaId.toNumber();
+    const m2 = maxDeltaId.toNumber();
+    let b = new bn_js_1.default(0);
+    let c = new bn_js_1.default(0);
+    for (let m = m1; m <= m2; m++) {
+        const binId = activeId.addn(m);
+        const pm = getQPriceFromId(binId.neg(), binStep);
+        b = b.add(pm);
+        const cDelta = new bn_js_1.default(m).mul(pm).div(maxDeltaId);
+        c = c.add(cDelta);
+    }
+    const denominator = b.sub(c);
+    if (denominator.isZero() || denominator.isNeg()) {
+        return { base: new bn_js_1.default(0), delta: new bn_js_1.default(0) };
+    }
+    let baseX0 = amountX.shln(SCALE_OFFSET).div(denominator);
+    const deltaX = baseX0.neg().div(maxDeltaId);
+    // Iterative refinement to ensure we don't exceed amountX
+    while (true) {
+        const totalAmountX = calculateAskSideAmount(activeId, binStep, minDeltaId, maxDeltaId, deltaX, baseX0);
+        if (totalAmountX.gt(amountX)) {
+            baseX0 = baseX0.subn(1);
+        }
+        else {
+            return { base: baseX0, delta: deltaX };
+        }
+    }
+}
+/**
+ * Finds x0 and deltaX for CURVE strategy.
+ *
+ * This is a wrapper that delegates to findX0AndDeltaXForCurveMirrored which
+ * produces a shape that mirrors the bid side's linear decrease.
+ *
+ * @param amountX - Total X amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param binStep - Bin step in basis points
+ * @param activeId - Active bin ID
+ * @returns { base: x0, delta: deltaX }
+ */
+function findX0AndDeltaXForCurve(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    return findX0AndDeltaXForCurveMirrored(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+}
+/**
+ * Builds liquidity strategy parameters for CURVE distribution.
+ *
+ * CURVE strategy concentrates liquidity near the active bin with amounts
+ * decreasing as you move away. This is achieved with negative deltaX/deltaY.
+ *
+ * @param amountX - Total X amount to deposit
+ * @param amountY - Total Y amount to deposit
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId)
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId)
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @param favorXInActiveId - Whether X is favored in the active bin
+ * @returns Strategy parameters { x0, y0, deltaX, deltaY }
+ */
+function buildCurveStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId = false) {
+    if (minDeltaId.gt(maxDeltaId)) {
+        return { x0: new bn_js_1.default(0), y0: new bn_js_1.default(0), deltaX: new bn_js_1.default(0), deltaY: new bn_js_1.default(0) };
+    }
+    const bidSideEndDeltaId = favorXInActiveId ? new bn_js_1.default(-1) : new bn_js_1.default(0);
+    const askSideStartDeltaId = favorXInActiveId ? new bn_js_1.default(0) : new bn_js_1.default(1);
+    const depositOnlyY = maxDeltaId.lte(bidSideEndDeltaId);
+    const depositOnlyX = minDeltaId.gte(askSideStartDeltaId);
+    if (depositOnlyY) {
+        const { base: y0, delta: deltaY } = findY0AndDeltaYForCurve(amountY, minDeltaId, maxDeltaId, activeId);
+        return { x0: new bn_js_1.default(0), y0, deltaX: new bn_js_1.default(0), deltaY };
+    }
+    if (depositOnlyX) {
+        const { base: x0, delta: deltaX } = findX0AndDeltaXForCurve(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+        return { x0, y0: new bn_js_1.default(0), deltaX, deltaY: new bn_js_1.default(0) };
+    }
+    // Both sides - calculate independently
+    const { base: y0, delta: deltaY } = findY0AndDeltaYForCurve(amountY, minDeltaId, bidSideEndDeltaId, activeId);
+    const { base: x0, delta: deltaX } = findX0AndDeltaXForCurve(amountX, askSideStartDeltaId, maxDeltaId, binStep, activeId);
+    return { x0, y0, deltaX, deltaY };
+}
+// =============================================================================
+// BID_ASK STRATEGY
+// =============================================================================
+/**
+ * Finds base deltaY for BID_ASK strategy.
+ *
+ * BID_ASK strategy has liquidity increasing away from active bin.
+ * Formula: amountY = y0 + deltaY * m
+ * Setting y0 = -deltaY * (m2 - 1) gives increasing amounts.
+ *
+ * @param amountY - Total Y amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @returns Base deltaY value
+ */
+function findBaseDeltaYForBidAsk(amountY, minDeltaId, maxDeltaId) {
+    if (minDeltaId.gt(maxDeltaId) || amountY.lte(new bn_js_1.default(0))) {
+        return new bn_js_1.default(0);
+    }
+    if (minDeltaId.eq(maxDeltaId)) {
+        return amountY;
+    }
+    const m1 = minDeltaId.neg();
+    const m2 = maxDeltaId.neg();
+    // sum(amounts) = y0 * (m1-m2+1) + deltaY * (m1*(m1+1)/2 - m2*(m2-1)/2)
+    // set y0 = -deltaY * (m2 - 1)
+    // A = (-m2+1) * (m1-m2+1) + (m1*(m1+1)/2 - m2*(m2-1)/2)
+    // deltaY = amountY / A
+    const b = m2.neg().addn(1).mul(m1.sub(m2).addn(1));
+    const c = m1.mul(m1.addn(1)).divn(2);
+    const d = m2.mul(m2.subn(1)).divn(2);
+    const a = b.add(c.sub(d));
+    if (a.isZero()) {
+        return amountY;
+    }
+    return amountY.div(a);
+}
+/**
+ * Finds y0 and deltaY for BID_ASK strategy with iterative refinement.
+ *
+ * @param amountY - Total Y amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param activeId - Active bin ID
+ * @returns { base: y0, delta: deltaY }
+ */
+function findY0AndDeltaYForBidAsk(amountY, minDeltaId, maxDeltaId, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
+        return { base: new bn_js_1.default(0), delta: new bn_js_1.default(0) };
+    }
+    const baseDeltaY = findBaseDeltaYForBidAsk(amountY, minDeltaId, maxDeltaId);
+    const m2 = maxDeltaId.neg();
+    // y0 is calculated once from initial baseDeltaY and kept constant (matches Meteora)
+    const y0 = baseDeltaY.neg().mul(m2.subn(1));
+    // Binary search for the correct deltaY that doesn't exceed amountY
+    let low = new bn_js_1.default(0);
+    let high = baseDeltaY.clone();
+    let result = new bn_js_1.default(0);
+    while (low.lte(high)) {
+        const mid = low.add(high).shrn(1);
+        const totalAmountY = calculateBidSideAmount(activeId, minDeltaId, maxDeltaId, mid, y0);
+        if (totalAmountY.lte(amountY)) {
+            result = mid;
+            low = mid.addn(1);
+        }
+        else {
+            high = mid.subn(1);
+        }
+    }
+    return { base: y0, delta: result };
+}
+/**
+ * Calculates the critical delta beyond which BID_ASK amounts will start decreasing.
+ *
+ * For BID_ASK, amountX = (x0 + deltaX * delta) * priceWeight
+ * where priceWeight decays exponentially as delta increases.
+ *
+ * The critical point is approximately 1 / (binStep / 10000) = 10000 / binStep.
+ * Beyond this point, exponential decay overwhelms linear growth.
+ *
+ * @param binStep - Bin step in basis points
+ * @returns Critical delta value
+ */
+function getCriticalDeltaForBidAsk(binStep) {
+    // Critical delta ≈ 1 / (binStep / 10000) = 10000 / binStep
+    // Using floor to be conservative
+    return Math.floor(10000 / binStep.toNumber());
+}
+/**
+ * Finds base deltaX for BID_ASK strategy.
+ *
+ * Formula: amountX = (x0 + deltaX * m) * price_weight
+ * Setting x0 = -m1 * deltaX + deltaX gives increasing amounts.
+ *
+ * IMPORTANT: This formula only produces monotonically increasing amounts
+ * when the range is within the critical delta (approximately 10000/binStep bins).
+ * For wider ranges, consider using multiple smaller positions.
+ *
+ * @param amountX - Total X amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param binStep - Bin step in basis points
+ * @param activeId - Active bin ID
+ * @returns Base deltaX value
+ */
+function findBaseDeltaXForBidAsk(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountX.lte(new bn_js_1.default(0))) {
+        return new bn_js_1.default(0);
+    }
+    // sum(amounts) = x0 * B + deltaX * C
+    // where B = sum(price_weights), C = sum(m * price_weight)
+    // setting x0 = -m1 * deltaX + deltaX = deltaX * (1 - m1)
+    // sum = deltaX * (1 - m1) * B + deltaX * C = deltaX * ((1-m1)*B + C)
+    // deltaX = amountX / ((1-m1)*B + C)
+    let b = new bn_js_1.default(0);
+    let c = new bn_js_1.default(0);
+    const m1 = minDeltaId;
+    const m2 = maxDeltaId.addn(1); // +1 to ensure no zero amount at active bin
+    for (let m = m1.toNumber(); m <= m2.toNumber(); m++) {
+        const binId = activeId.addn(m);
+        const pm = getQPriceFromId(binId.neg(), binStep);
+        const bDelta = m1.mul(pm);
+        b = b.add(bDelta);
+        const cDelta = new bn_js_1.default(m).mul(pm);
+        c = c.add(cDelta);
+    }
+    const denominator = c.sub(b);
+    if (denominator.isZero()) {
+        return new bn_js_1.default(0);
+    }
+    return amountX.shln(SCALE_OFFSET).div(denominator);
+}
+/**
+ * Finds x0 and deltaX for BID_ASK strategy with iterative refinement.
+ *
+ * @param amountX - Total X amount to distribute
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param binStep - Bin step in basis points
+ * @param activeId - Active bin ID
+ * @returns { base: x0, delta: deltaX }
+ */
+function findX0AndDeltaXForBidAsk(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    if (minDeltaId.gt(maxDeltaId) || amountX.lte(new bn_js_1.default(0)) || amountX.isZero()) {
+        return { base: new bn_js_1.default(0), delta: new bn_js_1.default(0) };
+    }
+    const baseDeltaX = findBaseDeltaXForBidAsk(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+    // x0 is calculated once from initial baseDeltaX and kept constant (matches Meteora)
+    const x0 = minDeltaId.neg().mul(baseDeltaX).add(baseDeltaX);
+    // Binary search for the correct deltaX that doesn't exceed amountX
+    let low = new bn_js_1.default(0);
+    let high = baseDeltaX.clone();
+    let result = new bn_js_1.default(0);
+    while (low.lte(high)) {
+        const mid = low.add(high).shrn(1);
+        const totalAmountX = calculateAskSideAmount(activeId, binStep, minDeltaId, maxDeltaId, mid, x0);
+        if (totalAmountX.lte(amountX)) {
+            result = mid;
+            low = mid.addn(1);
+        }
+        else {
+            high = mid.subn(1);
+        }
+    }
+    return { base: x0, delta: result };
+}
+/**
+ * Builds liquidity strategy parameters for BID_ASK distribution.
+ *
+ * BID_ASK strategy has liquidity increasing away from the active bin.
+ * This is achieved with positive deltaX/deltaY values.
+ *
+ * @param amountX - Total X amount to deposit
+ * @param amountY - Total Y amount to deposit
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId)
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId)
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @param favorXInActiveId - Whether X is favored in the active bin
+ * @returns Strategy parameters { x0, y0, deltaX, deltaY }
+ */
+function buildBidAskStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId = false) {
+    if (minDeltaId.gt(maxDeltaId)) {
+        return { x0: new bn_js_1.default(0), y0: new bn_js_1.default(0), deltaX: new bn_js_1.default(0), deltaY: new bn_js_1.default(0) };
+    }
+    const bidSideEndDeltaId = favorXInActiveId ? new bn_js_1.default(-1) : new bn_js_1.default(0);
+    const askSideStartDeltaId = favorXInActiveId ? new bn_js_1.default(0) : new bn_js_1.default(1);
+    const depositOnlyY = maxDeltaId.lte(bidSideEndDeltaId);
+    const depositOnlyX = minDeltaId.gte(askSideStartDeltaId);
+    if (depositOnlyY) {
+        const { base: y0, delta: deltaY } = findY0AndDeltaYForBidAsk(amountY, minDeltaId, maxDeltaId, activeId);
+        return { x0: new bn_js_1.default(0), y0, deltaX: new bn_js_1.default(0), deltaY };
+    }
+    if (depositOnlyX) {
+        const { base: x0, delta: deltaX } = findX0AndDeltaXForBidAsk(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+        return { x0, y0: new bn_js_1.default(0), deltaX, deltaY: new bn_js_1.default(0) };
+    }
+    // Both sides
+    const { base: y0, delta: deltaY } = findY0AndDeltaYForBidAsk(amountY, minDeltaId, bidSideEndDeltaId, activeId);
+    const { base: x0, delta: deltaX } = findX0AndDeltaXForBidAsk(amountX, askSideStartDeltaId, maxDeltaId, binStep, activeId);
+    return { x0, y0, deltaX, deltaY };
+}
+// =============================================================================
+// HELPER FUNCTIONS FOR AMOUNT CALCULATION
+// =============================================================================
+/**
+ * Calculates total Y amount for bid side bins using given parameters.
+ *
+ * @param activeId - Active bin ID
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param deltaY - Delta Y per bin
+ * @param y0 - Base Y amount
+ * @returns Total Y amount
+ */
+function calculateBidSideAmount(activeId, minDeltaId, maxDeltaId, deltaY, y0) {
+    let totalAmount = new bn_js_1.default(0);
+    const minBinId = activeId.add(minDeltaId);
+    const maxBinId = activeId.add(maxDeltaId);
+    for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
+        const deltaBin = activeId.toNumber() - binId;
+        const totalDeltaY = deltaY.muln(deltaBin);
+        const amountY = y0.add(totalDeltaY);
+        if (amountY.gtn(0)) {
+            totalAmount = totalAmount.add(amountY);
+        }
+    }
+    return totalAmount;
+}
+/**
+ * Calculates total X amount for ask side bins using given parameters.
+ *
+ * @param activeId - Active bin ID
+ * @param binStep - Bin step in basis points
+ * @param minDeltaId - Minimum delta ID
+ * @param maxDeltaId - Maximum delta ID
+ * @param deltaX - Delta X per bin
+ * @param x0 - Base X amount
+ * @returns Total X amount
+ */
+function calculateAskSideAmount(activeId, binStep, minDeltaId, maxDeltaId, deltaX, x0) {
+    let totalAmount = new bn_js_1.default(0);
+    const baseFactor = getQPriceBaseFactor(binStep);
+    const minBinId = activeId.add(minDeltaId);
+    const maxBinId = activeId.add(maxDeltaId);
+    // Start from maxBinId and iterate down
+    let inverseBasePrice = getQPriceFromId(maxBinId.neg(), binStep);
+    for (let binId = maxBinId.toNumber(); binId >= minBinId.toNumber(); binId--) {
+        const delta = binId - activeId.toNumber();
+        const totalDeltaX = deltaX.muln(delta);
+        const baseAmount = x0.add(totalDeltaX);
+        // Only calculate if baseAmount is positive (can't shift right on negative BN)
+        if (baseAmount.gtn(0)) {
+            const amountX = baseAmount.mul(inverseBasePrice).shrn(SCALE_OFFSET);
+            if (amountX.gtn(0)) {
+                totalAmount = totalAmount.add(amountX);
+            }
+        }
+        inverseBasePrice = inverseBasePrice.mul(baseFactor).shrn(SCALE_OFFSET);
+    }
+    return totalAmount;
+}
+// =============================================================================
+// UNIFIED STRATEGY BUILDER
+// =============================================================================
+/**
+ * Builds liquidity strategy parameters for the specified strategy type.
+ *
+ * This is the main entry point that dispatches to the appropriate strategy builder.
+ *
+ * @param strategyType - The type of strategy (SPOT, CURVE, or BID_ASK)
+ * @param amountX - Total X amount to deposit
+ * @param amountY - Total Y amount to deposit
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId)
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId)
+ * @param binStep - The bin step in basis points
+ * @param activeId - The active bin ID
+ * @param favorXInActiveId - Whether X is favored in the active bin
+ * @returns Strategy parameters { x0, y0, deltaX, deltaY }
+ */
+function buildStrategyParameters(strategyType, amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId = false) {
+    switch (strategyType) {
+        case StrategyType.SPOT:
+            return buildSpotStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId);
+        case StrategyType.CURVE:
+            return buildCurveStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId);
+        case StrategyType.BID_ASK:
+            return buildBidAskStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId);
+        default:
+            // Default to SPOT if unknown strategy type
+            return buildSpotStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, activeId, favorXInActiveId);
+    }
+}
+/**
+ * Maps a Distribution string to a StrategyType enum.
+ * All variants of a base distribution (e.g. SPOT, SPOT-IMBALANCED, SPOT-ONE-SIDE)
+ * map to the same underlying StrategyType.
+ */
+function distributionToStrategyType(distribution) {
+    var _a;
+    const mapping = {
+        'SPOT': StrategyType.SPOT, 'SPOT-IMBALANCED': StrategyType.SPOT, 'SPOT-ONE-SIDE': StrategyType.SPOT,
+        'CURVE': StrategyType.CURVE, 'CURVE-IMBALANCED': StrategyType.CURVE, 'CURVE-ONE-SIDE': StrategyType.CURVE,
+        'BID-ASK': StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': StrategyType.BID_ASK,
+    };
+    return (_a = mapping[distribution]) !== null && _a !== void 0 ? _a : StrategyType.SPOT;
+}
+/**
+ * Converts an array of HybridLiquidityDistribution layers into strategy parameters.
+ *
+ * For each layer, applies the percentage split to the total X/Y amounts and delegates
+ * to buildHybridStrategyParameters. The last layer with a non-zero percentage on each
+ * side receives the full remaining amount (sweep), ensuring no dust is left behind
+ * due to integer division.
+ *
+ * Layers where both X and Y percentages are 0 are skipped.
+ *
+ * @param hybridDistribution - Array of layer distribution configs (1-3 layers)
+ * @param amountX - Total X token amount to distribute across layers
+ * @param amountY - Total Y token amount to distribute across layers
+ * @param minDeltaId - Lower bin bound relative to active bin (negative)
+ * @param maxDeltaId - Upper bin bound relative to active bin (positive)
+ * @param binStep - Bin step of the DLMM pool
+ * @param activeId - Current active bin ID
+ * @returns One LiquidityStrategyParameters per active layer
+ */
+function distributionToHybridStrategy({ amountY, amountX, hybridDistribution, minDeltaId, maxDeltaId, binStep, activeId, }) {
+    // Validate: each side must sum to exactly 100% or 0%, and both cannot be 0%
+    const sumX = hybridDistribution.reduce((s, l) => s + l.x.percentage, 0);
+    const sumY = hybridDistribution.reduce((s, l) => s + l.y.percentage, 0);
+    if (sumX !== 100 && sumX !== 0) {
+        throw new Error(`X percentages must sum to 100 or 0 (got ${sumX})`);
+    }
+    if (sumY !== 100 && sumY !== 0) {
+        throw new Error(`Y percentages must sum to 100 or 0 (got ${sumY})`);
+    }
+    if (sumX === 0 && sumY === 0) {
+        throw new Error('Both X and Y percentages cannot be 0');
+    }
+    // Find last layer with non-zero percentage per side (dust goes here)
+    let lastActiveXIndex = -1;
+    let lastActiveYIndex = -1;
+    for (let i = hybridDistribution.length - 1; i >= 0; i--) {
+        if (lastActiveXIndex === -1 && hybridDistribution[i].x.percentage > 0)
+            lastActiveXIndex = i;
+        if (lastActiveYIndex === -1 && hybridDistribution[i].y.percentage > 0)
+            lastActiveYIndex = i;
+    }
+    const results = [];
+    let totalCalculatedX = new bn_js_1.default(0);
+    let totalCalculatedY = new bn_js_1.default(0);
+    for (let i = 0; i < hybridDistribution.length; i++) {
+        const { x, y } = hybridDistribution[i];
+        if (x.percentage === 0 && y.percentage === 0) {
+            throw new Error(`Unexpected error: Both sides (X and Y) cannot have zero deposits on layer ${i + 1}`);
+        }
+        let layerAmountX = amountX.mul(new bn_js_1.default(x.percentage)).div(new bn_js_1.default(100));
+        totalCalculatedX = totalCalculatedX.add(layerAmountX);
+        let layerAmountY = amountY.mul(new bn_js_1.default(y.percentage)).div(new bn_js_1.default(100));
+        totalCalculatedY = totalCalculatedY.add(layerAmountY);
+        // Add dust to the last active layer per side
+        if (i === lastActiveXIndex && amountX.gt(totalCalculatedX)) {
+            layerAmountX = layerAmountX.add(amountX.sub(totalCalculatedX));
+        }
+        if (i === lastActiveYIndex && amountY.gt(totalCalculatedY)) {
+            layerAmountY = layerAmountY.add(amountY.sub(totalCalculatedY));
+        }
+        const strategyParams = buildHybridStrategyParameters({
+            strategyTypeX: distributionToStrategyType(x.distribution),
+            strategyTypeY: distributionToStrategyType(y.distribution),
+            amountX: layerAmountX, // note to AI: amountX should be equal to layerAmountX
+            amountY: layerAmountY,
+            minDeltaId,
+            maxDeltaId,
+            binStep,
+            activeId,
+        });
+        results.push(Object.assign(Object.assign({}, strategyParams), { maxAmountX: layerAmountX, maxAmountY: layerAmountY }));
+    }
+    return results;
+}
+/**
+ * Builds liquidity strategy parameters for a hybrid distribution where X (ask)
+ * and Y (bid) sides use different strategy types (e.g. X=BID-ASK, Y=SPOT).
+ *
+ * Splits the bin range at the active bin and computes each side independently:
+ * - Left side (Y/bid): distributes amountY across [minDeltaId, 0] using strategyTypeY
+ * - Right side (X/ask): distributes amountX across [0, maxDeltaId] using strategyTypeX
+ *
+ * The active bin (deltaId=0) is included in both computations. The final result
+ * merges y0/deltaY from the left side with x0/deltaX from the right side, giving
+ * each token its own independent distribution curve.
+ *
+ * @param strategyTypeY - Distribution strategy for the Y (bid) side
+ * @param strategyTypeX - Distribution strategy for the X (ask) side
+ * @param amountX - Total X token amount to distribute
+ * @param amountY - Total Y token amount to distribute
+ * @param minDeltaId - Lower bin bound relative to active bin (negative)
+ * @param maxDeltaId - Upper bin bound relative to active bin (positive)
+ * @param binStep - Bin step of the DLMM pool
+ * @param activeId - Current active bin ID
+ * @returns Merged strategy parameters with independent X/Y distributions
+ */
+function buildHybridStrategyParameters({ strategyTypeY, strategyTypeX, amountY, amountX, minDeltaId, maxDeltaId, binStep, activeId, }) {
+    const favorXInActiveId = amountY.isZero();
+    // Left side (Y)
+    const leftSide = buildStrategyParameters(strategyTypeY, new bn_js_1.default(0), amountY, minDeltaId, new bn_js_1.default(0), binStep, activeId, favorXInActiveId);
+    // Right side (X)
+    const rightSide = buildStrategyParameters(strategyTypeX, amountX, new bn_js_1.default(0), new bn_js_1.default(0), maxDeltaId, binStep, activeId, favorXInActiveId);
+    return {
+        /** Base amount for X token (ask side) */
+        x0: rightSide.x0,
+        /** Base amount for Y token (bid side) */
+        y0: leftSide.y0,
+        /** Delta change per bin for X (0 for SPOT, negative for CURVE, positive for BID_ASK) */
+        deltaX: rightSide.deltaX,
+        /** Delta change per bin for Y (0 for SPOT, negative for CURVE, positive for BID_ASK) */
+        deltaY: leftSide.deltaY,
+    };
+}
+/**
+ * Divides a bin range into chunks of specified size.
+ *
+ * This is similar to Meteora's `chunkBinRange` but with a configurable chunk size
+ * instead of a fixed 70-bin limit.
+ *
+ * @param minBinId - The starting bin ID of the range (absolute bin ID)
+ * @param maxBinId - The ending bin ID of the range (absolute bin ID)
+ * @param chunkSize - Maximum number of bins per chunk
+ * @returns Array of bin range chunks
+ */
+function chunkBinRange(minBinId, maxBinId, chunkSize) {
+    const chunkedBinRange = [];
+    let startBinId = minBinId;
+    while (startBinId <= maxBinId) {
+        const endBinId = Math.min(startBinId + chunkSize - 1, maxBinId);
+        chunkedBinRange.push({
+            lowerBinId: startBinId,
+            upperBinId: endBinId,
+        });
+        startBinId += chunkSize;
+    }
+    return chunkedBinRange;
+}
+/**
+ * Converts strategy parameters to on-chain format with bit flag for negative values.
+ *
+ * The Solana program uses unsigned integers, so negative values are stored as
+ * positive with a bit flag indicating the sign.
+ *
+ * Bit flags:
+ * - Bit 0 (0b0001): x0 is negative
+ * - Bit 1 (0b0010): y0 is negative
+ * - Bit 2 (0b0100): deltaX is negative
+ * - Bit 3 (0b1000): deltaY is negative
+ *
+ * @param x0 - Base X amount (may be negative)
+ * @param y0 - Base Y amount (may be negative)
+ * @param deltaX - Delta X per bin (may be negative)
+ * @param deltaY - Delta Y per bin (may be negative)
+ * @returns Parameters with absolute values and bit flag
+ */
+function buildBitFlagAndNegateStrategyParameters(x0, y0, deltaX, deltaY) {
+    let bitFlag = 0;
+    if (x0.isNeg()) {
+        bitFlag |= 0b0001;
+        x0 = x0.neg();
+    }
+    if (y0.isNeg()) {
+        bitFlag |= 0b0010;
+        y0 = y0.neg();
+    }
+    if (deltaX.isNeg()) {
+        bitFlag |= 0b0100;
+        deltaX = deltaX.neg();
+    }
+    if (deltaY.isNeg()) {
+        bitFlag |= 0b1000;
+        deltaY = deltaY.neg();
+    }
+    return {
+        bitFlag,
+        x0,
+        y0,
+        deltaX,
+        deltaY,
+    };
+}
+/**
+ * Calculates amounts for each bin in a range.
+ *
+ * This function iterates through all bins and calculates the X/Y amount
+ * for each bin based on the strategy parameters.
+ *
+ * @param activeId - The active bin ID
+ * @param minDeltaId - Minimum delta ID relative to active bin
+ * @param maxDeltaId - Maximum delta ID relative to active bin
+ * @param deltaX - Delta X per bin
+ * @param deltaY - Delta Y per bin
+ * @param x0 - Base X amount
+ * @param y0 - Base Y amount
+ * @param binStep - Bin step in basis points
+ * @param favorXInActiveBin - Whether X is favored in active bin
+ * @returns Array of { binId, amountX, amountY } for each bin
+ */
+function toAmountIntoBins(activeId, minDeltaId, maxDeltaId, deltaX, deltaY, x0, y0, binStep, favorXInActiveBin) {
+    const results = [];
+    const bidSideEndDeltaId = favorXInActiveBin ? -1 : 0;
+    for (let delta = minDeltaId.toNumber(); delta <= maxDeltaId.toNumber(); delta++) {
+        const binId = activeId.toNumber() + delta;
+        if (delta <= bidSideEndDeltaId) {
+            // Bid side - Y token
+            const distance = -delta; // Distance from active bin (positive)
+            const amountY = y0.add(deltaY.muln(distance));
+            results.push({
+                binId,
+                amountX: new bn_js_1.default(0),
+                amountY: amountY.gtn(0) ? amountY : new bn_js_1.default(0),
+            });
+        }
+        else {
+            // Ask side - X token
+            const priceWeight = getQPriceFromId(new bn_js_1.default(binId).neg(), binStep);
+            const baseAmount = x0.add(deltaX.muln(delta));
+            const amountX = baseAmount.mul(priceWeight).shrn(SCALE_OFFSET);
+            results.push({
+                binId,
+                amountX: amountX.gtn(0) ? amountX : new bn_js_1.default(0),
+                amountY: new bn_js_1.default(0),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Chunks a deposit into multiple transactions based on bin range.
+ *
+ * This function:
+ * 1. Takes pre-built strategy parameters for the entire position
+ * 2. Chunks the bin range into smaller ranges
+ * 3. For each chunk, adjusts params and calculates amounts
+ *
+ * @param params - Strategy parameters from buildStrategyParameters (for entire position)
+ * @param minDeltaId - Minimum delta ID (lowerBinId - activeId)
+ * @param maxDeltaId - Maximum delta ID (upperBinId - activeId)
+ * @param activeId - Current active bin ID
+ * @param binStep - Bin step in basis points
+ * @param chunkSize - Maximum bins per chunk
+ * @param favorXInActiveBin - Whether X is favored in active bin
+ * @returns Array of chunked deposit parameters
+ */
+function chunkDepositParameters(params, minDeltaId, maxDeltaId, activeId, binStep, chunkSize, favorXInActiveBin = false) {
+    // Convert to absolute bin IDs for chunking
+    const lowerBinId = activeId.add(minDeltaId).toNumber();
+    const upperBinId = activeId.add(maxDeltaId).toNumber();
+    // Chunk the bin range
+    const chunks = chunkBinRange(lowerBinId, upperBinId, chunkSize);
+    // For each chunk, calculate the deposit parameters
+    const result = [];
+    for (const chunk of chunks) {
+        const chunkMinDeltaId = new bn_js_1.default(chunk.lowerBinId).sub(activeId);
+        const chunkMaxDeltaId = new bn_js_1.default(chunk.upperBinId).sub(activeId);
+        // Reset uninvolved params for this chunk
+        const chunkParams = resetUninvolvedLiquidityParams(chunkMinDeltaId, chunkMaxDeltaId, favorXInActiveBin, params);
+        // Calculate amounts for this chunk using toAmountIntoBins
+        const binsAmounts = toAmountIntoBins(activeId, chunkMinDeltaId, chunkMaxDeltaId, chunkParams.deltaX, chunkParams.deltaY, chunkParams.x0, chunkParams.y0, binStep, favorXInActiveBin);
+        // Sum up amounts
+        const { totalXAmount, totalYAmount } = binsAmounts.reduce((acc, bin) => ({
+            totalXAmount: acc.totalXAmount.add(bin.amountX),
+            totalYAmount: acc.totalYAmount.add(bin.amountY),
+        }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+        result.push({
+            lowerBinId: chunk.lowerBinId,
+            upperBinId: chunk.upperBinId,
+            minDeltaId: chunkMinDeltaId,
+            maxDeltaId: chunkMaxDeltaId,
+            params: chunkParams,
+            maxAmountX: totalXAmount,
+            maxAmountY: totalYAmount,
+        });
+    }
+    return result;
+}
+/**
+ * Chunks a bin range with a custom initial chunk size and uniform subsequent chunk size.
+ *
+ * @param minBinId - The minimum bin ID of the range
+ * @param maxBinId - The maximum bin ID of the range
+ * @param initialChunkSize - Size of the first chunk (e.g., 150 bins)
+ * @param subsequentChunkSize - Size of subsequent chunks (e.g., 69 bins)
+ * @returns Array of chunk ranges with lowerBinId and upperBinId
+ */
+function chunkBinRangeWithInitialSize(minBinId, maxBinId, initialChunkSize, subsequentChunkSize) {
+    const chunkedBinRange = [];
+    let startBinId = minBinId;
+    let isFirstChunk = true;
+    while (startBinId <= maxBinId) {
+        const currentChunkSize = isFirstChunk ? initialChunkSize : subsequentChunkSize;
+        const endBinId = Math.min(startBinId + currentChunkSize - 1, maxBinId);
+        chunkedBinRange.push({
+            lowerBinId: startBinId,
+            upperBinId: endBinId,
+        });
+        startBinId += currentChunkSize;
+        isFirstChunk = false;
+    }
+    return chunkedBinRange;
+}
+/**
+ * Chunks deposit parameters with a custom initial chunk size.
+ *
+ * This is useful when the first deposit can accommodate a larger bin range
+ * (e.g., 150 bins for a fresh position) but subsequent deposits need smaller
+ * chunks due to compute limits.
+ *
+ * @param params - The liquidity strategy parameters
+ * @param minDeltaId - Minimum delta from active bin
+ * @param maxDeltaId - Maximum delta from active bin
+ * @param activeId - The current active bin ID
+ * @param binStep - The bin step of the pool
+ * @param initialChunkSize - Size of the first chunk (e.g., 150 bins)
+ * @param subsequentChunkSize - Size of subsequent chunks (e.g., 69 bins)
+ * @param favorXInActiveBin - Whether to favor token X in the active bin
+ * @returns Array of chunked deposit parameters
+ */
+function chunkDepositParametersWithInitialSize(params, minDeltaId, maxDeltaId, activeId, binStep, initialChunkSize, subsequentChunkSize, favorXInActiveBin = false) {
+    // Convert to absolute bin IDs for chunking
+    const lowerBinId = activeId.add(minDeltaId).toNumber();
+    const upperBinId = activeId.add(maxDeltaId).toNumber();
+    // Chunk the bin range with initial size
+    const chunks = chunkBinRangeWithInitialSize(lowerBinId, upperBinId, initialChunkSize, subsequentChunkSize);
+    // For each chunk, calculate the deposit parameters
+    const result = [];
+    for (const chunk of chunks) {
+        const chunkMinDeltaId = new bn_js_1.default(chunk.lowerBinId).sub(activeId);
+        const chunkMaxDeltaId = new bn_js_1.default(chunk.upperBinId).sub(activeId);
+        // Reset uninvolved params for this chunk
+        const chunkParams = resetUninvolvedLiquidityParams(chunkMinDeltaId, chunkMaxDeltaId, favorXInActiveBin, params);
+        // Calculate amounts for this chunk using toAmountIntoBins
+        const binsAmounts = toAmountIntoBins(activeId, chunkMinDeltaId, chunkMaxDeltaId, chunkParams.deltaX, chunkParams.deltaY, chunkParams.x0, chunkParams.y0, binStep, favorXInActiveBin);
+        // Sum up amounts
+        const { totalXAmount, totalYAmount } = binsAmounts.reduce((acc, bin) => ({
+            totalXAmount: acc.totalXAmount.add(bin.amountX),
+            totalYAmount: acc.totalYAmount.add(bin.amountY),
+        }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+        result.push({
+            lowerBinId: chunk.lowerBinId,
+            upperBinId: chunk.upperBinId,
+            minDeltaId: chunkMinDeltaId,
+            maxDeltaId: chunkMaxDeltaId,
+            params: chunkParams,
+            maxAmountX: totalXAmount,
+            maxAmountY: totalYAmount,
+        });
+    }
+    return result;
+}