@meteora-ag/dlmm 1.6.0-rc.18 → 1.6.0-rc.20

package/dist/index.mjs

@@ -11779,645 +11779,190 @@ function getTokenProgramId(lbPairState) {
   };
 }
 
-// src/dlmm/helpers/index.ts
-function chunks(array, size) {
-  return Array.apply(0, new Array(Math.ceil(array.length / size))).map(
-    (_, index) => array.slice(index * size, (index + 1) * size)
+// src/dlmm/helpers/rebalance/rebalancePosition.ts
+import { SYSVAR_CLOCK_PUBKEY } from "@solana/web3.js";
+import BN11 from "bn.js";
+import Decimal6 from "decimal.js";
+function buildBitFlagAndNegateStrategyParameters(x0, y0, deltaX, deltaY) {
+  let bitFlag = 0;
+  if (x0.isNeg()) {
+    bitFlag |= 1;
+    x0 = x0.neg();
+  }
+  if (y0.isNeg()) {
+    bitFlag |= 2;
+    y0 = y0.neg();
+  }
+  if (deltaX.isNeg()) {
+    bitFlag |= 4;
+    deltaX = deltaX.neg();
+  }
+  if (deltaY.isNeg()) {
+    bitFlag |= 8;
+    deltaY = deltaY.neg();
+  }
+  return {
+    bitFlag,
+    x0,
+    y0,
+    deltaX,
+    deltaY
+  };
+}
+function toRebalancePositionBinData(positionData) {
+  return positionData.positionBinData.map(
+    ({
+      binId,
+      price,
+      pricePerToken,
+      positionXAmount,
+      positionYAmount,
+      positionFeeXAmount,
+      positionFeeYAmount,
+      positionRewardAmount
+    }) => {
+      return {
+        binId,
+        price,
+        pricePerToken,
+        amountX: new BN11(positionXAmount),
+        amountY: new BN11(positionYAmount),
+        claimableRewardAmount: positionRewardAmount.map(
+          (amount) => new BN11(amount)
+        ),
+        claimableFeeXAmount: new BN11(positionFeeXAmount),
+        claimableFeeYAmount: new BN11(positionFeeYAmount)
+      };
+    }
   );
 }
-function range(min, max, mapfn) {
-  const length = max - min + 1;
-  return Array.from({ length }, (_, i) => mapfn(min + i));
+function getDepositBinIds(activeId, deposits) {
+  const uniqueBinId = /* @__PURE__ */ new Set();
+  for (const { minDeltaId, maxDeltaId } of deposits) {
+    const minBinId = activeId.add(minDeltaId);
+    const maxBinId = activeId.add(maxDeltaId);
+    for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
+      uniqueBinId.add(binId);
+    }
+  }
+  const binIds = Array.from(uniqueBinId);
+  binIds.sort((a, b) => a - b);
+  return binIds;
 }
-async function chunkedFetchMultiplePoolAccount(program, pks, chunkSize = 100) {
-  const accounts = (await Promise.all(
-    chunks(pks, chunkSize).map(
-      (chunk) => program.account.lbPair.fetchMultiple(chunk)
-    )
-  )).flat();
-  return accounts.filter(Boolean);
+function findMinMaxBinIdWithLiquidity(rebalancePositionBinData) {
+  let minBinId = null;
+  let maxBinId = null;
+  for (const binData of rebalancePositionBinData) {
+    if (binData.amountX.isZero() && binData.amountY.isZero() && binData.claimableFeeXAmount.isZero() && binData.claimableFeeYAmount.isZero() && binData.claimableRewardAmount.every((amount) => amount.isZero())) {
+      continue;
+    }
+    if (minBinId == null || binData.binId < minBinId) {
+      minBinId = binData.binId;
+    }
+    if (maxBinId == null || binData.binId > maxBinId) {
+      maxBinId = binData.binId;
+    }
+  }
+  return [minBinId, maxBinId];
 }
-async function chunkedFetchMultipleBinArrayBitmapExtensionAccount(program, pks, chunkSize = 100) {
-  const accounts = (await Promise.all(
-    chunks(pks, chunkSize).map(
-      (chunk) => program.account.binArrayBitmapExtension.fetchMultiple(chunk)
-    )
-  )).flat();
-  return accounts;
+function onlyDepositToBidSide(maxDeltaId, favorXInActiveBin) {
+  if (favorXInActiveBin) {
+    return maxDeltaId.lt(new BN11(0));
+  }
+  return maxDeltaId.lte(new BN11(0));
 }
-function getOutAmount(bin, inAmount, swapForY) {
-  return swapForY ? mulShr(inAmount, bin.price, SCALE_OFFSET, 1 /* Down */) : shlDiv(inAmount, bin.price, SCALE_OFFSET, 1 /* Down */);
+function onlyDepositToAskSide(minDeltaId, favorXInActiveBin) {
+  if (favorXInActiveBin) {
+    return minDeltaId.gte(new BN11(0));
+  }
+  return minDeltaId.gt(new BN11(0));
 }
-async function getTokenDecimals(conn, mint) {
-  const token = await getMint(conn, mint);
-  return await token.decimals;
+function getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0) {
+  const amountInBins = [];
+  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.mul(new BN11(deltaBin));
+    const amountY = y0.add(totalDeltaY);
+    amountInBins.push({
+      binId: new BN11(binId),
+      amountX: new BN11(0),
+      amountY
+    });
+  }
+  return amountInBins;
 }
-var getOrCreateATAInstruction = async (connection, tokenMint, owner, programId, payer = owner, allowOwnerOffCurve = true) => {
-  programId = programId ?? TOKEN_PROGRAM_ID3;
-  const toAccount = getAssociatedTokenAddressSync(
-    tokenMint,
-    owner,
-    allowOwnerOffCurve,
-    programId,
-    ASSOCIATED_TOKEN_PROGRAM_ID
-  );
-  try {
-    await getAccount(connection, toAccount, connection.commitment, programId);
-    return { ataPubKey: toAccount, ix: void 0 };
-  } catch (e) {
-    if (e instanceof TokenAccountNotFoundError || e instanceof TokenInvalidAccountOwnerError) {
-      const ix = createAssociatedTokenAccountIdempotentInstruction(
-        payer,
-        toAccount,
-        owner,
-        tokenMint,
-        programId,
-        ASSOCIATED_TOKEN_PROGRAM_ID
-      );
-      return { ataPubKey: toAccount, ix };
-    } else {
-      console.error("Error::getOrCreateATAInstruction", e);
-      throw e;
-    }
+function getAmountInBinsAskSide(activeId, binStep, minDeltaId, maxDeltaId, deltaX, x0) {
+  const binCount = maxDeltaId.sub(minDeltaId).add(new BN11(1));
+  const minBinId = activeId.add(minDeltaId);
+  const maxBinId = activeId.add(maxDeltaId);
+  const amountInBins = new Array(binCount.toNumber());
+  const base = getQPriceBaseFactor(binStep);
+  let inverseBasePrice = pow(base, maxBinId.neg());
+  for (let binId = maxBinId.toNumber(); binId >= minBinId.toNumber(); binId--) {
+    const delta = binId - activeId.toNumber();
+    const totalDeltaX = deltaX.mul(new BN11(delta));
+    const amountX = x0.add(totalDeltaX).mul(inverseBasePrice).shrn(SCALE_OFFSET);
+    const idx = binId - minBinId.toNumber();
+    amountInBins[idx] = {
+      binId: new BN11(binId),
+      amountX,
+      amountY: new BN11(0)
+    };
+    inverseBasePrice = inverseBasePrice.mul(base).shrn(SCALE_OFFSET);
   }
-};
-async function getTokenBalance(conn, tokenAccount) {
-  const acc = await getAccount(conn, tokenAccount);
-  return acc.amount;
+  return amountInBins;
 }
-var parseLogs = (eventParser, logs) => {
-  if (!logs.length)
-    throw new Error("No logs found");
-  for (const event of eventParser?.parseLogs(logs)) {
-    return event.data;
+function toAmountIntoBins(activeId, minDeltaId, maxDeltaId, deltaX, deltaY, x0, y0, binStep, favorXInActiveBin) {
+  if (onlyDepositToBidSide(maxDeltaId, favorXInActiveBin)) {
+    return getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0);
   }
-  throw new Error("No events found");
-};
-var wrapSOLInstruction = (from, to, amount) => {
-  return [
-    SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: to,
-      lamports: amount
-    }),
-    new TransactionInstruction3({
-      keys: [
-        {
-          pubkey: to,
-          isSigner: false,
-          isWritable: true
-        }
-      ],
-      data: Buffer.from(new Uint8Array([17])),
-      programId: TOKEN_PROGRAM_ID3
-    })
-  ];
-};
-var unwrapSOLInstruction = async (owner, allowOwnerOffCurve = true) => {
-  const wSolATAAccount = getAssociatedTokenAddressSync(
-    NATIVE_MINT,
-    owner,
-    allowOwnerOffCurve
+  if (onlyDepositToAskSide(minDeltaId, favorXInActiveBin)) {
+    return getAmountInBinsAskSide(
+      activeId,
+      binStep,
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      x0
+    );
+  }
+  const [bidSideEndDeltaId, askSideStartDeltaId] = favorXInActiveBin ? [-1, 0] : [0, 1];
+  const amountInBinsBidSide = getAmountInBinsBidSide(
+    activeId,
+    minDeltaId,
+    new BN11(bidSideEndDeltaId),
+    deltaY,
+    y0
   );
-  if (wSolATAAccount) {
-    const closedWrappedSolInstruction = createCloseAccountInstruction(
-      wSolATAAccount,
-      owner,
-      owner,
-      [],
-      TOKEN_PROGRAM_ID3
+  const amountInBinsAskSide = getAmountInBinsAskSide(
+    activeId,
+    binStep,
+    new BN11(askSideStartDeltaId),
+    maxDeltaId,
+    deltaX,
+    x0
+  );
+  return amountInBinsBidSide.concat(amountInBinsAskSide);
+}
+function getLiquidity(x, y, price) {
+  const px = price.mul(x);
+  const shly = y.shln(SCALE_OFFSET);
+  return px.add(shly);
+}
+function computeCompositionFee(binStep, sParameters3, vParameters3, outAmountX, inAmountX, outAmountY, inAmountY) {
+  if (outAmountX.gt(inAmountX)) {
+    const delta = inAmountY.sub(outAmountY);
+    const totalFeeRate = getTotalFee(
+      binStep.toNumber(),
+      sParameters3,
+      vParameters3
     );
-    return closedWrappedSolInstruction;
+    const feeAmount = delta.mul(totalFeeRate);
+    return feeAmount.mul(FEE_PRECISION.add(totalFeeRate)).div(FEE_PRECISION.pow(new BN11(2)));
   }
-  return null;
-};
-async function chunkedGetMultipleAccountInfos(connection, pks, chunkSize = 100) {
-  const accountInfos = (await Promise.all(
-    chunks(pks, chunkSize).map(
-      (chunk) => connection.getMultipleAccountsInfo(chunk)
-    )
-  )).flat();
-  return accountInfos;
-}
-var getEstimatedComputeUnitUsageWithBuffer = async (connection, instructions, feePayer, buffer) => {
-  if (!buffer) {
-    buffer = 0.1;
-  }
-  buffer = Math.max(0, buffer);
-  buffer = Math.min(1, buffer);
-  const estimatedComputeUnitUsage = await getSimulationComputeUnits(
-    connection,
-    instructions,
-    feePayer,
-    []
-  );
-  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
-  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
-    extraComputeUnitBuffer = MAX_CU_BUFFER;
-  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
-    extraComputeUnitBuffer = MIN_CU_BUFFER;
-  }
-  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
-};
-var getEstimatedComputeUnitIxWithBuffer = async (connection, instructions, feePayer, buffer) => {
-  const units = await getEstimatedComputeUnitUsageWithBuffer(
-    connection,
-    instructions,
-    feePayer,
-    buffer
-  ).catch((error) => {
-    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
-    return 14e5;
-  });
-  return ComputeBudgetProgram2.setComputeUnitLimit({ units });
-};
-function createProgram(connection, opt) {
-  const cluster = opt?.cluster || "mainnet-beta";
-  const provider = new AnchorProvider(
-    connection,
-    {},
-    AnchorProvider.defaultOptions()
-  );
-  return new Program2(
-    { ...dlmm_default, address: LBCLMM_PROGRAM_IDS[cluster] },
-    provider
-  );
-}
-function decodeAccount(program, accountName, buffer) {
-  return program.coder.accounts.decode(accountName, buffer);
-}
-function getAccountDiscriminator(accountName) {
-  return dlmm_default.accounts.find(
-    (acc) => acc.name.toLowerCase() === accountName.toLowerCase()
-  )?.discriminator;
-}
-function capSlippagePercentage(slippage) {
-  if (slippage > 100) {
-    slippage = 100;
-  }
-  if (slippage < 0) {
-    slippage = 0;
-  }
-  return slippage;
-}
-
-// src/dlmm/helpers/accountFilters.ts
-import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
-var presetParameter2BinStepFilter = (binStep) => {
-  return {
-    memcmp: {
-      bytes: bs58.encode(binStep.toArrayLike(Buffer, "le", 2)),
-      offset: 8
-    }
-  };
-};
-var presetParameter2BaseFactorFilter = (baseFactor) => {
-  return {
-    memcmp: {
-      bytes: bs58.encode(baseFactor.toArrayLike(Buffer, "le", 2)),
-      offset: 8 + 2
-    }
-  };
-};
-var presetParameter2BaseFeePowerFactor = (baseFeePowerFactor) => {
-  return {
-    memcmp: {
-      bytes: bs58.encode(baseFeePowerFactor.toArrayLike(Buffer, "le", 1)),
-      offset: 8 + 22
-    }
-  };
-};
-var binArrayLbPairFilter = (lbPair) => {
-  return {
-    memcmp: {
-      bytes: lbPair.toBase58(),
-      offset: 8 + 16
-    }
-  };
-};
-var positionOwnerFilter = (owner) => {
-  return {
-    memcmp: {
-      bytes: owner.toBase58(),
-      offset: 8 + 32
-    }
-  };
-};
-var positionLbPairFilter = (lbPair) => {
-  return {
-    memcmp: {
-      bytes: bs58.encode(lbPair.toBuffer()),
-      offset: 8
-    }
-  };
-};
-var positionV2Filter = () => {
-  return {
-    memcmp: {
-      bytes: bs58.encode(Buffer.from(getAccountDiscriminator("positionV2"))),
-      offset: 0
-    }
-  };
-};
-
-// src/dlmm/helpers/positions/index.ts
-import BN13 from "bn.js";
-
-// src/dlmm/helpers/positions/wrapper.ts
-import BN12 from "bn.js";
-function combineBaseAndExtendedPositionBinData(base, extended) {
-  const combinedLiquidityShares = base.liquidityShares;
-  const combinedRewardInfos = base.rewardInfos;
-  const combinedFeeInfos = base.feeInfos;
-  for (const binData of extended) {
-    combinedLiquidityShares.push(binData.liquidityShare);
-    combinedRewardInfos.push(binData.rewardInfo);
-    combinedFeeInfos.push(binData.feeInfo);
-  }
-  return {
-    liquidityShares: combinedLiquidityShares,
-    rewardInfos: combinedRewardInfos,
-    feeInfos: combinedFeeInfos
-  };
-}
-function wrapPosition(program, key, account) {
-  const disc = account.data.subarray(0, 8);
-  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
-    const state = decodeAccount(
-      program,
-      "positionV2",
-      account.data
-    );
-    const extended = decodeExtendedPosition(
-      state,
-      program,
-      account.data.subarray(8 + POSITION_MIN_SIZE)
-    );
-    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
-      state,
-      extended
-    );
-    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
-  } else {
-    throw new Error("Unknown position account");
-  }
-}
-var PositionV2Wrapper = class {
-  constructor(positionAddress, inner, extended, combinedPositionBinData) {
-    this.positionAddress = positionAddress;
-    this.inner = inner;
-    this.extended = extended;
-    this.combinedPositionBinData = combinedPositionBinData;
-  }
-  address() {
-    return this.positionAddress;
-  }
-  totalClaimedRewards() {
-    return this.inner.totalClaimedRewards;
-  }
-  feeOwner() {
-    return this.inner.feeOwner;
-  }
-  lockReleasePoint() {
-    return this.inner.lockReleasePoint;
-  }
-  operator() {
-    return this.inner.operator;
-  }
-  totalClaimedFeeYAmount() {
-    return this.inner.totalClaimedFeeYAmount;
-  }
-  totalClaimedFeeXAmount() {
-    return this.inner.totalClaimedFeeXAmount;
-  }
-  lbPair() {
-    return this.inner.lbPair;
-  }
-  lowerBinId() {
-    return new BN12(this.inner.lowerBinId);
-  }
-  upperBinId() {
-    return new BN12(this.inner.upperBinId);
-  }
-  liquidityShares() {
-    return this.combinedPositionBinData.liquidityShares;
-  }
-  rewardInfos() {
-    return this.combinedPositionBinData.rewardInfos;
-  }
-  feeInfos() {
-    return this.combinedPositionBinData.feeInfos;
-  }
-  lastUpdatedAt() {
-    return this.inner.lastUpdatedAt;
-  }
-  getBinArrayIndexesCoverage() {
-    const isExtended = this.extended.length > 0;
-    if (isExtended) {
-      return getBinArrayIndexesCoverage(this.lowerBinId(), this.upperBinId());
-    } else {
-      const lowerBinArrayIndex = binIdToBinArrayIndex(this.lowerBinId());
-      const upperBinArrayIndex = lowerBinArrayIndex.add(new BN12(1));
-      return [lowerBinArrayIndex, upperBinArrayIndex];
-    }
-  }
-  getBinArrayKeysCoverage(programId) {
-    return this.getBinArrayIndexesCoverage().map(
-      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
-    );
-  }
-  version() {
-    return 1 /* V2 */;
-  }
-  owner() {
-    return this.inner.owner;
-  }
-  width() {
-    return this.upperBinId().sub(this.lowerBinId()).add(new BN12(1));
-  }
-};
-
-// src/dlmm/helpers/positions/index.ts
-function getBinArrayIndexesCoverage(lowerBinId, upperBinId) {
-  const lowerBinArrayIndex = binIdToBinArrayIndex(lowerBinId);
-  const upperBinArrayIndex = binIdToBinArrayIndex(upperBinId);
-  const binArrayIndexes = [];
-  for (let i = lowerBinArrayIndex.toNumber(); i <= upperBinArrayIndex.toNumber(); i++) {
-    binArrayIndexes.push(new BN13(i));
-  }
-  return binArrayIndexes;
-}
-function getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId) {
-  const binArrayIndexes = getBinArrayIndexesCoverage(lowerBinId, upperBinId);
-  return binArrayIndexes.map((index) => {
-    return deriveBinArray(lbPair, index, programId)[0];
-  });
-}
-function getBinArrayAccountMetasCoverage(lowerBinId, upperBinId, lbPair, programId) {
-  return getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId).map(
-    (key) => {
-      return {
-        pubkey: key,
-        isSigner: false,
-        isWritable: true
-      };
-    }
-  );
-}
-function getPositionLowerUpperBinIdWithLiquidity(position) {
-  const binWithLiquidity = position.positionBinData.filter(
-    (b) => !new BN13(b.binLiquidity).isZero() || !new BN13(b.positionFeeXAmount.toString()).isZero() || !new BN13(b.positionFeeYAmount.toString()).isZero() || !new BN13(b.positionRewardAmount[0].toString()).isZero() || !new BN13(b.positionRewardAmount[1].toString()).isZero()
-  );
-  return binWithLiquidity.length > 0 ? {
-    lowerBinId: new BN13(binWithLiquidity[0].binId),
-    upperBinId: new BN13(binWithLiquidity[binWithLiquidity.length - 1].binId)
-  } : null;
-}
-function isPositionNoFee(position) {
-  return position.feeX.isZero() && position.feeY.isZero();
-}
-function isPositionNoReward(position) {
-  return position.rewardOne.isZero() && position.rewardTwo.isZero();
-}
-function chunkBinRange(minBinId, maxBinId) {
-  const chunkedBinRange = [];
-  let startBinId = minBinId;
-  while (startBinId <= maxBinId) {
-    const endBinId = Math.min(
-      startBinId + DEFAULT_BIN_PER_POSITION.toNumber() - 1,
-      maxBinId
-    );
-    chunkedBinRange.push({
-      lowerBinId: startBinId,
-      upperBinId: endBinId
-    });
-    startBinId += DEFAULT_BIN_PER_POSITION.toNumber();
-  }
-  return chunkedBinRange;
-}
-async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
-  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
-  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
-  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
-    return 0;
-  } else {
-    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
-      DEFAULT_BIN_PER_POSITION
-    );
-    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
-    const [minimumLamports, rentExemptionLamports] = await Promise.all([
-      connection.getMinimumBalanceForRentExemption(0),
-      connection.getMinimumBalanceForRentExemption(expandSize)
-    ]);
-    return rentExemptionLamports - minimumLamports;
-  }
-}
-function getExtendedPositionBinCount(minBinId, maxBinId) {
-  const width = maxBinId.sub(minBinId).addn(1);
-  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
-  return extended.lte(new BN13(0)) ? new BN13(0) : extended;
-}
-function decodeExtendedPosition(base, program, bytes) {
-  const width = base.upperBinId - base.lowerBinId + 1;
-  const extendedWidth = width - DEFAULT_BIN_PER_POSITION.toNumber();
-  const extendedPosition = [];
-  for (let i = 0; i < extendedWidth; i++) {
-    const offset = i * POSITION_BIN_DATA_SIZE;
-    const data = bytes.subarray(offset, offset + POSITION_BIN_DATA_SIZE);
-    const decodedPositionBinData = program.coder.types.decode(
-      // TODO: Find a type safe way
-      "positionBinData",
-      data
-    );
-    extendedPosition.push(decodedPositionBinData);
-  }
-  return extendedPosition;
-}
-
-// src/dlmm/helpers/rebalance/rebalancePosition.ts
-import { SYSVAR_CLOCK_PUBKEY } from "@solana/web3.js";
-import BN14 from "bn.js";
-import Decimal6 from "decimal.js";
-function buildBitFlagAndNegateStrategyParameters(x0, y0, deltaX, deltaY) {
-  let bitFlag = 0;
-  if (x0.isNeg()) {
-    bitFlag |= 1;
-    x0 = x0.neg();
-  }
-  if (y0.isNeg()) {
-    bitFlag |= 2;
-    y0 = y0.neg();
-  }
-  if (deltaX.isNeg()) {
-    bitFlag |= 4;
-    deltaX = deltaX.neg();
-  }
-  if (deltaY.isNeg()) {
-    bitFlag |= 8;
-    deltaY = deltaY.neg();
-  }
-  return {
-    bitFlag,
-    x0,
-    y0,
-    deltaX,
-    deltaY
-  };
-}
-function toRebalancePositionBinData(positionData) {
-  return positionData.positionBinData.map(
-    ({
-      binId,
-      price,
-      pricePerToken,
-      positionXAmount,
-      positionYAmount,
-      positionFeeXAmount,
-      positionFeeYAmount,
-      positionRewardAmount
-    }) => {
-      return {
-        binId,
-        price,
-        pricePerToken,
-        amountX: new BN14(positionXAmount),
-        amountY: new BN14(positionYAmount),
-        claimableRewardAmount: positionRewardAmount.map(
-          (amount) => new BN14(amount)
-        ),
-        claimableFeeXAmount: new BN14(positionFeeXAmount),
-        claimableFeeYAmount: new BN14(positionFeeYAmount)
-      };
-    }
-  );
-}
-function getDepositBinIds(activeId, deposits) {
-  const uniqueBinId = /* @__PURE__ */ new Set();
-  for (const { minDeltaId, maxDeltaId } of deposits) {
-    const minBinId = activeId.add(minDeltaId);
-    const maxBinId = activeId.add(maxDeltaId);
-    for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
-      uniqueBinId.add(binId);
-    }
-  }
-  const binIds = Array.from(uniqueBinId);
-  binIds.sort((a, b) => a - b);
-  return binIds;
-}
-function findMinMaxBinIdWithLiquidity(rebalancePositionBinData) {
-  let minBinId = null;
-  let maxBinId = null;
-  for (const binData of rebalancePositionBinData) {
-    if (binData.amountX.isZero() && binData.amountY.isZero() && binData.claimableFeeXAmount.isZero() && binData.claimableFeeYAmount.isZero() && binData.claimableRewardAmount.every((amount) => amount.isZero())) {
-      continue;
-    }
-    if (minBinId == null || binData.binId < minBinId) {
-      minBinId = binData.binId;
-    }
-    if (maxBinId == null || binData.binId > maxBinId) {
-      maxBinId = binData.binId;
-    }
-  }
-  return [minBinId, maxBinId];
-}
-function onlyDepositToBidSide(maxDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return maxDeltaId.lt(new BN14(0));
-  }
-  return maxDeltaId.lte(new BN14(0));
-}
-function onlyDepositToAskSide(minDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return minDeltaId.gte(new BN14(0));
-  }
-  return minDeltaId.gt(new BN14(0));
-}
-function getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0) {
-  const amountInBins = [];
-  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.mul(new BN14(deltaBin));
-    const amountY = y0.add(totalDeltaY);
-    amountInBins.push({
-      binId: new BN14(binId),
-      amountX: new BN14(0),
-      amountY
-    });
-  }
-  return amountInBins;
-}
-function getAmountInBinsAskSide(activeId, binStep, minDeltaId, maxDeltaId, deltaX, x0) {
-  const binCount = maxDeltaId.sub(minDeltaId).add(new BN14(1));
-  const minBinId = activeId.add(minDeltaId);
-  const maxBinId = activeId.add(maxDeltaId);
-  const amountInBins = new Array(binCount.toNumber());
-  const base = getQPriceBaseFactor(binStep);
-  let inverseBasePrice = pow(base, maxBinId.neg());
-  for (let binId = maxBinId.toNumber(); binId >= minBinId.toNumber(); binId--) {
-    const delta = binId - activeId.toNumber();
-    const totalDeltaX = deltaX.mul(new BN14(delta));
-    const amountX = x0.add(totalDeltaX).mul(inverseBasePrice).shrn(SCALE_OFFSET);
-    const idx = binId - minBinId.toNumber();
-    amountInBins[idx] = {
-      binId: new BN14(binId),
-      amountX,
-      amountY: new BN14(0)
-    };
-    inverseBasePrice = inverseBasePrice.mul(base).shrn(SCALE_OFFSET);
-  }
-  return amountInBins;
-}
-function toAmountIntoBins(activeId, minDeltaId, maxDeltaId, deltaX, deltaY, x0, y0, binStep, favorXInActiveBin) {
-  if (onlyDepositToBidSide(maxDeltaId, favorXInActiveBin)) {
-    return getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0);
-  }
-  if (onlyDepositToAskSide(minDeltaId, favorXInActiveBin)) {
-    return getAmountInBinsAskSide(
-      activeId,
-      binStep,
-      minDeltaId,
-      maxDeltaId,
-      deltaX,
-      x0
-    );
-  }
-  const [bidSideEndDeltaId, askSideStartDeltaId] = favorXInActiveBin ? [-1, 0] : [0, 1];
-  const amountInBinsBidSide = getAmountInBinsBidSide(
-    activeId,
-    minDeltaId,
-    new BN14(bidSideEndDeltaId),
-    deltaY,
-    y0
-  );
-  const amountInBinsAskSide = getAmountInBinsAskSide(
-    activeId,
-    binStep,
-    new BN14(askSideStartDeltaId),
-    maxDeltaId,
-    deltaX,
-    x0
-  );
-  return amountInBinsBidSide.concat(amountInBinsAskSide);
-}
-function getLiquidity(x, y, price) {
-  const px = price.mul(x);
-  const shly = y.shln(SCALE_OFFSET);
-  return px.add(shly);
-}
-function computeCompositionFee(binStep, sParameters3, vParameters3, outAmountX, inAmountX, outAmountY, inAmountY) {
-  if (outAmountX.gt(inAmountX)) {
-    const delta = inAmountY.sub(outAmountY);
-    const totalFeeRate = getTotalFee(
-      binStep.toNumber(),
-      sParameters3,
-      vParameters3
-    );
-    const feeAmount = delta.mul(totalFeeRate);
-    return feeAmount.mul(FEE_PRECISION.add(totalFeeRate)).div(FEE_PRECISION.pow(new BN14(2)));
-  }
-  return new BN14(0);
+  return new BN11(0);
 }
 function simulateDepositBin(binId, binStep, amountX, amountY, bin) {
   if (!bin) {
@@ -12466,8 +12011,8 @@ var RebalancePosition = class {
   constructor(positionAddress, positionData, lbPair, activeBin, shouldClaimFee, shouldClaimReward, currentTimestamp) {
     this.address = positionAddress;
     this.rebalancePositionBinData = toRebalancePositionBinData(positionData);
-    this.lowerBinId = new BN14(positionData.lowerBinId);
-    this.upperBinId = new BN14(positionData.upperBinId);
+    this.lowerBinId = new BN11(positionData.lowerBinId);
+    this.upperBinId = new BN11(positionData.upperBinId);
     this.lbPair = lbPair;
     this.shouldClaimFee = shouldClaimFee;
     this.shouldClaimReward = shouldClaimReward;
@@ -12490,7 +12035,7 @@ var RebalancePosition = class {
     ]);
     const lbPair = decodeAccount(program, "lbPair", lbPairAccount.data);
     const clock = ClockLayout.decode(clockAccount.data);
-    const activeBinArrayIdx = binIdToBinArrayIndex(new BN14(lbPair.activeId));
+    const activeBinArrayIdx = binIdToBinArrayIndex(new BN11(lbPair.activeId));
     const [activeBinArrayPubkey] = deriveBinArray(
       pairAddress,
       activeBinArrayIdx,
@@ -12501,7 +12046,7 @@ var RebalancePosition = class {
     );
     const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(activeBinArrayIdx);
     const idx = getBinIdIndexInBinArray(
-      new BN14(lbPair.activeId),
+      new BN11(lbPair.activeId),
       lowerBinId,
       upperBinId
     );
@@ -12518,21 +12063,21 @@ var RebalancePosition = class {
   }
   _simulateDeposit(binStep, tokenXDecimal, tokenYDecimal, deposits, simulatedWithdrawResult) {
     const { liquidityAndFeeXWithdrawn, liquidityAndFeeYWithdrawn } = simulatedWithdrawResult;
-    const activeId = new BN14(this.lbPair.activeId);
+    const activeId = new BN11(this.lbPair.activeId);
     const depositBinIds = getDepositBinIds(activeId, deposits);
     if (depositBinIds.length > 0) {
       const depositMinBinId = depositBinIds[0];
       const depositMaxBinId = depositBinIds[depositBinIds.length - 1];
       this._simulateResize(
-        new BN14(depositMinBinId),
-        new BN14(depositMaxBinId),
+        new BN11(depositMinBinId),
+        new BN11(depositMaxBinId),
         binStep,
         tokenXDecimal,
         tokenYDecimal
       );
     }
-    let totalAmountXDeposited = new BN14(0);
-    let totalAmountYDeposited = new BN14(0);
+    let totalAmountXDeposited = new BN11(0);
+    let totalAmountYDeposited = new BN11(0);
     const addLiquidityParam = [];
     for (const {
       x0,
@@ -12638,23 +12183,23 @@ var RebalancePosition = class {
       actualTotalAmountXDeposited = actualTotalAmountXDeposited.sub(
         actualLiquidityAndFeeXWithdrawn
       );
-      actualLiquidityAndFeeXWithdrawn = new BN14(0);
+      actualLiquidityAndFeeXWithdrawn = new BN11(0);
     } else {
       actualLiquidityAndFeeXWithdrawn = actualLiquidityAndFeeXWithdrawn.sub(
         actualTotalAmountXDeposited
       );
-      actualTotalAmountXDeposited = new BN14(0);
+      actualTotalAmountXDeposited = new BN11(0);
     }
     if (actualTotalAmountYDeposited.gt(actualLiquidityAndFeeYWithdrawn)) {
       actualTotalAmountYDeposited = actualTotalAmountYDeposited.sub(
         actualLiquidityAndFeeYWithdrawn
       );
-      actualLiquidityAndFeeYWithdrawn = new BN14(0);
+      actualLiquidityAndFeeYWithdrawn = new BN11(0);
     } else {
       actualLiquidityAndFeeYWithdrawn = actualLiquidityAndFeeYWithdrawn.sub(
         actualTotalAmountYDeposited
       );
-      actualTotalAmountYDeposited = new BN14(0);
+      actualTotalAmountYDeposited = new BN11(0);
     }
     return {
       result: {
@@ -12674,10 +12219,10 @@ var RebalancePosition = class {
     const [minBinId, maxBinId] = findMinMaxBinIdWithLiquidity(
       this.rebalancePositionBinData
     );
-    const newMinBinId = new BN14(
+    const newMinBinId = new BN11(
       Math.min(depositMinBinId.toNumber(), minBinId ?? Number.MAX_SAFE_INTEGER)
     );
-    const newMaxBinId = new BN14(
+    const newMaxBinId = new BN11(
       Math.max(depositMaxBinId.toNumber(), maxBinId ?? Number.MIN_SAFE_INTEGER)
     );
     if (newMinBinId.lt(this.lowerBinId)) {
@@ -12693,11 +12238,11 @@ var RebalancePosition = class {
           binId: binId.toNumber(),
           price: adjustedPrice.toString(),
           pricePerToken: adjustedPrice.toString(),
-          amountX: new BN14(0),
-          amountY: new BN14(0),
-          claimableRewardAmount: [new BN14(0), new BN14(0)],
-          claimableFeeXAmount: new BN14(0),
-          claimableFeeYAmount: new BN14(0)
+          amountX: new BN11(0),
+          amountY: new BN11(0),
+          claimableRewardAmount: [new BN11(0), new BN11(0)],
+          claimableFeeXAmount: new BN11(0),
+          claimableFeeYAmount: new BN11(0)
         });
       }
     } else {
@@ -12719,11 +12264,11 @@ var RebalancePosition = class {
           binId: binId.toNumber(),
           price: adjustedPrice.toString(),
           pricePerToken: adjustedPrice.toString(),
-          amountX: new BN14(0),
-          amountY: new BN14(0),
-          claimableRewardAmount: [new BN14(0), new BN14(0)],
-          claimableFeeXAmount: new BN14(0),
-          claimableFeeYAmount: new BN14(0)
+          amountX: new BN11(0),
+          amountY: new BN11(0),
+          claimableRewardAmount: [new BN11(0), new BN11(0)],
+          claimableFeeXAmount: new BN11(0),
+          claimableFeeYAmount: new BN11(0)
         });
       }
     } else {
@@ -12736,10 +12281,10 @@ var RebalancePosition = class {
     this.upperBinId = newMaxBinId;
   }
   _simulateWithdraw(withdraws) {
-    let liquidityAndFeeXWithdrawn = new BN14(0);
-    let liquidityAndFeeYWithdrawn = new BN14(0);
-    let rewardsAmountClaimed = [new BN14(0), new BN14(0)];
-    const activeId = new BN14(this.lbPair.activeId);
+    let liquidityAndFeeXWithdrawn = new BN11(0);
+    let liquidityAndFeeYWithdrawn = new BN11(0);
+    let rewardsAmountClaimed = [new BN11(0), new BN11(0)];
+    const activeId = new BN11(this.lbPair.activeId);
     for (const { minBinId, maxBinId, bps } of withdraws) {
       const fromBinId = minBinId ?? activeId;
       const toBinId = maxBinId ?? activeId;
@@ -12764,13 +12309,13 @@ var RebalancePosition = class {
           liquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn.add(
             binData.claimableFeeYAmount
           );
-          binData.claimableFeeXAmount = new BN14(0);
-          binData.claimableFeeYAmount = new BN14(0);
+          binData.claimableFeeXAmount = new BN11(0);
+          binData.claimableFeeYAmount = new BN11(0);
         }
         if (this.shouldClaimReward) {
           for (const [idx2, amount] of binData.claimableRewardAmount.entries()) {
             rewardsAmountClaimed[idx2] = rewardsAmountClaimed[idx2].add(amount);
-            binData.claimableRewardAmount[idx2] = new BN14(0);
+            binData.claimableRewardAmount[idx2] = new BN11(0);
           }
         }
         this.rebalancePositionBinData[idx] = binData;
@@ -12799,7 +12344,7 @@ var RebalancePosition = class {
     if (withdraws.length == 0 && deposits.length == 0) {
       throw "No rebalance action";
     }
-    const activeId = new BN14(this.lbPair.activeId);
+    const activeId = new BN11(this.lbPair.activeId);
     withdraws = validateAndSortRebalanceWithdraw(withdraws, activeId);
     deposits = validateAndSortRebalanceDeposit(deposits);
     const beforeWidth = getPositionWidthWithMinWidth(
@@ -12819,15 +12364,15 @@ var RebalancePosition = class {
       this.upperBinId.toNumber()
     );
     const widthDelta = afterWidth - beforeWidth;
-    let rentalCostLamports = new BN14(0);
+    let rentalCostLamports = new BN11(0);
     if (widthDelta != 0) {
       const sizeChanges = Math.abs(widthDelta) * POSITION_BIN_DATA_SIZE;
       const [minimumLamports, rentExemptionLamports] = await Promise.all([
         connection.getMinimumBalanceForRentExemption(0),
         connection.getMinimumBalanceForRentExemption(sizeChanges)
       ]);
-      const lamportChanges = new BN14(rentExemptionLamports).sub(
-        new BN14(minimumLamports)
+      const lamportChanges = new BN11(rentExemptionLamports).sub(
+        new BN11(minimumLamports)
       );
       if (widthDelta > 0) {
         rentalCostLamports = rentalCostLamports.add(lamportChanges);
@@ -12849,8 +12394,8 @@ var RebalancePosition = class {
     };
   }
   totalAmounts() {
-    let totalAmountX = new BN14(0);
-    let totalAmountY = new BN14(0);
+    let totalAmountX = new BN11(0);
+    let totalAmountY = new BN11(0);
     for (const binData of this.rebalancePositionBinData) {
       totalAmountX = totalAmountX.add(binData.amountX);
       totalAmountY = totalAmountY.add(binData.amountY);
@@ -12858,8 +12403,8 @@ var RebalancePosition = class {
     return [totalAmountX, totalAmountY];
   }
   totalFeeAmounts() {
-    let totalFeeXAmount = new BN14(0);
-    let totalFeeYAmount = new BN14(0);
+    let totalFeeXAmount = new BN11(0);
+    let totalFeeYAmount = new BN11(0);
     for (const binData of this.rebalancePositionBinData) {
       totalFeeXAmount = totalFeeXAmount.add(binData.claimableFeeXAmount);
       totalFeeYAmount = totalFeeYAmount.add(binData.claimableFeeYAmount);
@@ -12867,7 +12412,7 @@ var RebalancePosition = class {
     return [totalFeeXAmount, totalFeeYAmount];
   }
   totalRewardAmounts() {
-    let totalRewardAmounts = [new BN14(0), new BN14(0)];
+    let totalRewardAmounts = [new BN11(0), new BN11(0)];
     for (const binData of this.rebalancePositionBinData) {
       totalRewardAmounts[0] = totalRewardAmounts[0].add(
         binData.claimableRewardAmount[0]
@@ -12935,7 +12480,7 @@ function binRangeToBinIdArray(minBinId, maxBinId) {
   const fromBinId = minBinId.toNumber();
   const toBinId = maxBinId.toNumber();
   for (let binId = fromBinId; binId <= toBinId; binId++) {
-    binIdArray.push(new BN14(binId));
+    binIdArray.push(new BN11(binId));
   }
   return binIdArray;
 }
@@ -12950,36 +12495,36 @@ function getRebalanceBinArrayIndexesAndBitmapCoverage(adds, removes, activeId, p
     if (maxBinId == null) {
       maxBinId = activeId;
     }
-    let binArrayIndex = binIdToBinArrayIndex(new BN14(minBinId));
-    const upperBinId = new BN14(maxBinId);
+    let binArrayIndex = binIdToBinArrayIndex(new BN11(minBinId));
+    const upperBinId = new BN11(maxBinId);
     while (true) {
       indexMap.set(binArrayIndex.toNumber(), true);
       const [binArrayLowerBinId, binArrayUpperBinId] = getBinArrayLowerUpperBinId(binArrayIndex);
       if (upperBinId.gte(binArrayLowerBinId) && upperBinId.lte(binArrayUpperBinId)) {
         break;
       } else {
-        binArrayIndex = binArrayIndex.add(new BN14(1));
+        binArrayIndex = binArrayIndex.add(new BN11(1));
       }
     }
   });
   adds.forEach((value) => {
     const minBinId = activeId + value.minDeltaId;
     const maxBinId = activeId + value.maxDeltaId;
-    let binArrayIndex = binIdToBinArrayIndex(new BN14(minBinId));
-    const upperBinId = new BN14(maxBinId);
+    let binArrayIndex = binIdToBinArrayIndex(new BN11(minBinId));
+    const upperBinId = new BN11(maxBinId);
     while (true) {
       indexMap.set(binArrayIndex.toNumber(), true);
       const [binArrayLowerBinId, binArrayUpperBinId] = getBinArrayLowerUpperBinId(binArrayIndex);
       if (upperBinId.gte(binArrayLowerBinId) && upperBinId.lte(binArrayUpperBinId)) {
         break;
       } else {
-        binArrayIndex = binArrayIndex.add(new BN14(1));
+        binArrayIndex = binArrayIndex.add(new BN11(1));
       }
     }
   });
-  const binArrayIndexes = Array.from(indexMap.keys()).map((idx) => new BN14(idx));
+  const binArrayIndexes = Array.from(indexMap.keys()).map((idx) => new BN11(idx));
   const requireBitmapExtension = binArrayIndexes.some(
-    (index) => isOverflowDefaultBinArrayBitmap(new BN14(index))
+    (index) => isOverflowDefaultBinArrayBitmap(new BN11(index))
   );
   return {
     binArrayIndexes,
@@ -12988,505 +12533,1109 @@ function getRebalanceBinArrayIndexesAndBitmapCoverage(adds, removes, activeId, p
 }
 
 // src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
-import BN18 from "bn.js";
+import BN15 from "bn.js";
+
+// src/dlmm/helpers/rebalance/liquidity_strategy/bidAsk.ts
+import BN12 from "bn.js";
+function findBaseDeltaY(amountY, minDeltaId, maxDeltaId) {
+  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN12(0))) {
+    return new BN12(0);
+  }
+  if (minDeltaId.eq(maxDeltaId)) {
+    return amountY;
+  }
+  const m1 = minDeltaId.neg().subn(1);
+  const m2 = maxDeltaId.neg();
+  const b = m2.neg().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));
+  return amountY.div(a);
+}
+function findY0AndDeltaY(amountY, minDeltaId, maxDeltaId, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
+    return {
+      base: new BN12(0),
+      delta: new BN12(0)
+    };
+  }
+  let baseDeltaY = findBaseDeltaY(amountY, minDeltaId, maxDeltaId);
+  const y0 = baseDeltaY.neg().mul(maxDeltaId).add(baseDeltaY);
+  while (true) {
+    const amountInBins = getAmountInBinsBidSide(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      baseDeltaY,
+      y0
+    );
+    const totalAmountY = amountInBins.reduce((acc, { amountY: amountY2 }) => {
+      return acc.add(amountY2);
+    }, new BN12(0));
+    if (totalAmountY.gt(amountY)) {
+      baseDeltaY = baseDeltaY.sub(new BN12(1));
+    } else {
+      return {
+        base: y0,
+        delta: baseDeltaY
+      };
+    }
+  }
+}
+function findBaseDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN12(0))) {
+    return new BN12(0);
+  }
+  let b = new BN12(0);
+  let c = new BN12(0);
+  let m1 = minDeltaId;
+  let m2 = maxDeltaId.addn(1);
+  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 BN12(m).mul(pm);
+    c = c.add(cDelta);
+  }
+  return amountX.shln(SCALE_OFFSET).div(c.sub(b));
+}
+function findX0AndDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN12(0)) || amountX.isZero()) {
+    return {
+      base: new BN12(0),
+      delta: new BN12(0)
+    };
+  }
+  let baseDeltaX = findBaseDeltaX(
+    amountX,
+    minDeltaId,
+    maxDeltaId,
+    binStep,
+    activeId
+  );
+  const x0 = minDeltaId.neg().mul(baseDeltaX).add(baseDeltaX);
+  while (true) {
+    const amountInBins = getAmountInBinsAskSide(
+      activeId,
+      binStep,
+      minDeltaId,
+      maxDeltaId,
+      baseDeltaX,
+      x0
+    );
+    const totalAmountX = amountInBins.reduce((acc, { amountX: amountX2 }) => {
+      return acc.add(amountX2);
+    }, new BN12(0));
+    if (totalAmountX.gt(amountX)) {
+      baseDeltaX = baseDeltaX.sub(new BN12(1));
+    } else {
+      return {
+        base: x0,
+        delta: baseDeltaX
+      };
+    }
+  }
+}
+var BidAskStrategyParameterBuilder = class {
+  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    return findX0AndDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  }
+  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
+    return findY0AndDeltaY(amountY, minDeltaId, maxDeltaId, activeId);
+  }
+  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
+    const deltaX = amountY.div(
+      maxDeltaId.addn(1).mul(maxDeltaId.addn(2)).divn(2)
+    );
+    const x0 = minDeltaId.neg().mul(deltaX).add(deltaX);
+    const totalAmountX = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      new BN12(0),
+      x0,
+      new BN12(0),
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountX);
+    }, new BN12(0));
+    return {
+      base: x0,
+      delta: deltaX,
+      amountX: totalAmountX
+    };
+  }
+  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
+    const m1 = minDeltaId.neg().subn(1);
+    const m2 = maxDeltaId.neg();
+    const a1 = m2.neg().mul(m1.sub(m2).addn(1));
+    const a2 = m1.mul(m1.addn(1)).divn(2);
+    const a3 = m2.mul(m2.subn(1)).divn(2);
+    const a = a1.add(a2.sub(a3));
+    const deltaY = amountXInQuoteValue.div(a);
+    const y0 = deltaY.neg().mul(m2).add(deltaY);
+    const amountY = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      new BN12(0),
+      deltaY,
+      new BN12(0),
+      y0,
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountY);
+    }, new BN12(0));
+    return {
+      base: y0,
+      delta: deltaY,
+      amountY
+    };
+  }
+};
 
-// src/dlmm/helpers/rebalance/liquidity_strategy/bidAsk.ts
-import BN15 from "bn.js";
-function findBaseDeltaY(amountY, minDeltaId, maxDeltaId) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN15(0))) {
-    return new BN15(0);
+// src/dlmm/helpers/rebalance/liquidity_strategy/curve.ts
+import BN13 from "bn.js";
+function findBaseY0(amountY, minDeltaId, maxDeltaId) {
+  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN13(0))) {
+    return new BN13(0);
   }
   if (minDeltaId.eq(maxDeltaId)) {
     return amountY;
   }
-  const m1 = minDeltaId.neg().subn(1);
+  const m1 = minDeltaId.neg();
   const m2 = maxDeltaId.neg();
-  const b = m2.neg().mul(m1.sub(m2).addn(1));
+  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.add(c.sub(d));
+  const a = b.sub(c.sub(d).div(m1.addn(1)));
   return amountY.div(a);
 }
-function findY0AndDeltaY(amountY, minDeltaId, maxDeltaId, activeId) {
+function findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId) {
   if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
     return {
-      base: new BN15(0),
-      delta: new BN15(0)
+      base: new BN13(0),
+      delta: new BN13(0)
     };
   }
-  let baseDeltaY = findBaseDeltaY(amountY, minDeltaId, maxDeltaId);
-  const y0 = baseDeltaY.neg().mul(maxDeltaId).add(baseDeltaY);
+  let baseY0 = findBaseY0(amountY, minDeltaId, maxDeltaId);
   while (true) {
+    const deltaY = baseY0.neg().div(minDeltaId.neg().addn(1));
     const amountInBins = getAmountInBinsBidSide(
       activeId,
       minDeltaId,
       maxDeltaId,
-      baseDeltaY,
-      y0
+      deltaY,
+      baseY0
     );
     const totalAmountY = amountInBins.reduce((acc, { amountY: amountY2 }) => {
       return acc.add(amountY2);
-    }, new BN15(0));
+    }, new BN13(0));
     if (totalAmountY.gt(amountY)) {
-      baseDeltaY = baseDeltaY.sub(new BN15(1));
+      baseY0 = baseY0.sub(new BN13(1));
     } else {
       return {
-        base: y0,
-        delta: baseDeltaY
+        base: baseY0,
+        delta: deltaY
       };
     }
   }
 }
-function findBaseDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN15(0))) {
-    return new BN15(0);
+function findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN13(0))) {
+    return new BN13(0);
   }
-  let b = new BN15(0);
-  let c = new BN15(0);
+  let b = new BN13(0);
+  let c = new BN13(0);
   let m1 = minDeltaId;
-  let m2 = maxDeltaId.addn(1);
+  let m2 = maxDeltaId;
   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 BN15(m).mul(pm);
+    b = b.add(pm);
+    const cDelta = new BN13(m).mul(pm).div(m2);
     c = c.add(cDelta);
   }
-  return amountX.shln(SCALE_OFFSET).div(c.sub(b));
+  return amountX.shln(SCALE_OFFSET).div(b.sub(c));
+}
+function findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN13(0)) || amountX.isZero()) {
+    return {
+      base: new BN13(0),
+      delta: new BN13(0)
+    };
+  }
+  let baseX0 = findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  const deltaX = baseX0.neg().div(maxDeltaId);
+  while (true) {
+    const amountInBins = getAmountInBinsAskSide(
+      activeId,
+      binStep,
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      baseX0
+    );
+    const totalAmountX = amountInBins.reduce((acc, { amountX: amountX2 }) => {
+      return acc.add(amountX2);
+    }, new BN13(0));
+    if (totalAmountX.gt(amountX)) {
+      baseX0 = baseX0.sub(new BN13(1));
+    } else {
+      return {
+        base: baseX0,
+        delta: deltaX
+      };
+    }
+  }
+}
+var CurveStrategyParameterBuilder = class {
+  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    return findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  }
+  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
+    return findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId);
+  }
+  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
+    const x0 = amountY.muln(2).div(maxDeltaId.addn(1));
+    const deltaX = x0.neg().div(maxDeltaId);
+    const totalAmountX = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      new BN13(0),
+      x0,
+      new BN13(0),
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountX);
+    }, new BN13(0));
+    return {
+      base: x0,
+      delta: deltaX,
+      amountX: totalAmountX
+    };
+  }
+  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
+    const m1 = minDeltaId.neg();
+    const m2 = maxDeltaId.neg();
+    const a1 = m1.sub(m2).addn(1);
+    const a2 = m1.mul(m1.addn(1)).divn(2);
+    const a3 = m2.mul(m2.subn(1)).divn(2);
+    const a = m1.sub(a3.sub(a2)).div(m1);
+    const y0 = amountXInQuoteValue.div(a);
+    const deltaY = y0.neg().div(m1);
+    const amountY = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      new BN13(0),
+      deltaY,
+      new BN13(0),
+      y0,
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountY);
+    }, new BN13(0));
+    return {
+      base: y0,
+      delta: deltaY,
+      amountY
+    };
+  }
+};
+
+// src/dlmm/helpers/rebalance/liquidity_strategy/spot.ts
+import BN14 from "bn.js";
+function findY0(amountY, minDeltaId, maxDeltaId) {
+  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN14(0)) || amountY.isZero()) {
+    return new BN14(0);
+  }
+  const m1 = minDeltaId.neg();
+  const m2 = maxDeltaId.neg();
+  const delta = m1.sub(m2).addn(1);
+  return amountY.div(delta);
+}
+function findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  let totalWeight = new BN14(0);
+  const minBinId = activeId.add(minDeltaId);
+  const maxBinId = activeId.add(maxDeltaId);
+  let baseFactor = getQPriceBaseFactor(binStep);
+  let basePrice = getQPriceFromId(maxBinId.neg(), binStep);
+  for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
+    totalWeight = totalWeight.add(basePrice);
+    basePrice = basePrice.mul(baseFactor).shrn(SCALE_OFFSET);
+  }
+  return amountX.shln(SCALE_OFFSET).div(totalWeight);
+}
+function findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN14(0)) || amountX.isZero()) {
+    return new BN14(0);
+  }
+  let x0 = findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  while (true) {
+    const amountInBins = getAmountInBinsAskSide(
+      activeId,
+      binStep,
+      minDeltaId,
+      maxDeltaId,
+      new BN14(0),
+      x0
+    );
+    const totalAmountX = amountInBins.reduce((acc, bin) => {
+      return acc.add(bin.amountX);
+    }, new BN14(0));
+    if (totalAmountX.lt(amountX)) {
+      x0 = x0.add(new BN14(1));
+    } else {
+      x0 = x0.sub(new BN14(1));
+      return x0;
+    }
+  }
+}
+var SpotStrategyParameterBuilder = class {
+  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    return {
+      base: findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId),
+      delta: new BN14(0)
+    };
+  }
+  findYParameters(amountY, minDeltaId, maxDeltaId, _activeId) {
+    return {
+      base: findY0(amountY, minDeltaId, maxDeltaId),
+      delta: new BN14(0)
+    };
+  }
+  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
+    const x0 = amountY.div(maxDeltaId.addn(1));
+    const totalAmountX = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      new BN14(0),
+      new BN14(0),
+      x0,
+      new BN14(0),
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountX);
+    }, new BN14(0));
+    return {
+      base: new BN14(x0.toString()),
+      delta: new BN14(0),
+      amountX: totalAmountX
+    };
+  }
+  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
+    const y0 = amountXInQuoteValue.div(maxDeltaId.sub(minDeltaId).addn(1));
+    const amountY = toAmountIntoBins(
+      activeId,
+      minDeltaId,
+      maxDeltaId,
+      new BN14(0),
+      new BN14(0),
+      new BN14(0),
+      y0,
+      binStep,
+      favorXInActiveBin
+    ).reduce((acc, bin) => {
+      return acc.add(bin.amountY);
+    }, new BN14(0));
+    return {
+      base: y0,
+      delta: new BN14(0),
+      amountY
+    };
+  }
+};
+
+// src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
+import Decimal7 from "decimal.js";
+function getLiquidityStrategyParameterBuilder(strategyType) {
+  switch (strategyType) {
+    case 0 /* Spot */:
+      return new SpotStrategyParameterBuilder();
+    case 1 /* Curve */:
+      return new CurveStrategyParameterBuilder();
+    case 2 /* BidAsk */:
+      return new BidAskStrategyParameterBuilder();
+    default:
+      throw new Error("Strategy not supported");
+  }
+}
+function suggestBalancedXParametersFromY(y0, deltaY, minDeltaId, maxDeltaId, activeId, binStep, favorXInActiveBin, builder) {
+  const endDeltaIdBidSide = favorXInActiveBin ? new BN15(-1) : new BN15(0);
+  if (maxDeltaId.lte(endDeltaIdBidSide)) {
+    return {
+      base: new BN15(0),
+      delta: new BN15(0),
+      amountX: new BN15(0)
+    };
+  }
+  const minYDeltaId = minDeltaId;
+  const maxYDeltaId = endDeltaIdBidSide;
+  const totalAmountY = toAmountIntoBins(
+    activeId,
+    minYDeltaId,
+    maxYDeltaId,
+    new BN15(0),
+    deltaY,
+    new BN15(0),
+    y0,
+    binStep,
+    favorXInActiveBin
+  ).reduce((acc, bin) => {
+    return acc.add(bin.amountY);
+  }, new BN15(0));
+  const minXDeltaId = maxYDeltaId.addn(1);
+  const maxXDeltaId = maxDeltaId;
+  return builder.suggestBalancedXParametersFromY(
+    activeId,
+    binStep,
+    favorXInActiveBin,
+    minXDeltaId,
+    maxXDeltaId,
+    totalAmountY
+  );
+}
+function getAutoFillAmountByRebalancedPosition(rebalancePosition, strategyType) {
+  let liquidityInBidSide = new BN15(0);
+  let liquidityInAskSide = new BN15(0);
+  const builder = getLiquidityStrategyParameterBuilder(strategyType);
+  const { lbPair } = rebalancePosition;
+  let favorXInActiveBin = false;
+  let activeIdIndex = -1;
+  for (const [
+    idx,
+    binData
+  ] of rebalancePosition.rebalancePositionBinData.entries()) {
+    const liquidityBid = binData.amountY;
+    const liquidityAsk = new Decimal7(binData.price).mul(new Decimal7(binData.amountX.toString())).floor().toString();
+    liquidityInBidSide = liquidityInBidSide.add(liquidityBid);
+    liquidityInAskSide = liquidityInAskSide.add(new BN15(liquidityAsk));
+    if (binData.binId == lbPair.activeId) {
+      favorXInActiveBin = binData.amountX.gt(binData.amountY);
+      activeIdIndex = idx;
+    }
+  }
+  if (liquidityInAskSide.gt(liquidityInBidSide)) {
+    const minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
+    let maxBinId;
+    if (activeIdIndex == -1) {
+      maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
+    } else {
+      maxBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+    }
+    const minDeltaId = minBinId - lbPair.activeId;
+    const maxDeltaId = maxBinId - lbPair.activeId;
+    const { amountY } = builder.suggestBalancedYParametersFromX(
+      new BN15(lbPair.activeId),
+      new BN15(lbPair.binStep),
+      favorXInActiveBin,
+      new BN15(minDeltaId),
+      new BN15(maxDeltaId),
+      liquidityInAskSide
+    );
+    const [_, positionAmountY] = rebalancePosition.totalAmounts();
+    return {
+      amount: BN15.max(amountY.sub(positionAmountY), new BN15(0)),
+      isBidSide: true
+    };
+  } else if (liquidityInAskSide.lt(liquidityInBidSide)) {
+    const maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
+    let minBinId;
+    if (activeIdIndex == -1) {
+      minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
+    } else {
+      minBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+    }
+    const minDeltaId = lbPair.activeId - minBinId;
+    const maxDeltaId = lbPair.activeId - maxBinId;
+    const { amountX } = builder.suggestBalancedXParametersFromY(
+      new BN15(lbPair.activeId),
+      new BN15(lbPair.binStep),
+      favorXInActiveBin,
+      new BN15(minDeltaId),
+      new BN15(maxDeltaId),
+      liquidityInBidSide
+    );
+    const [positionAmountX] = rebalancePosition.totalAmounts();
+    return {
+      amount: BN15.max(amountX.sub(positionAmountX), new BN15(0)),
+      isBidSide: false
+    };
+  } else {
+    return {
+      amount: new BN15(0),
+      isBidSide: false
+    };
+  }
 }
-function findX0AndDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN15(0)) || amountX.isZero()) {
+function suggestBalancedYParametersFromX(x0, deltaX, minDeltaId, maxDeltaId, activeId, binStep, favorXInActiveBin, builder) {
+  const startDeltaIdAskSide = favorXInActiveBin ? new BN15(0) : new BN15(1);
+  if (minDeltaId.gte(startDeltaIdAskSide)) {
     return {
       base: new BN15(0),
-      delta: new BN15(0)
+      delta: new BN15(0),
+      amountY: new BN15(0)
     };
   }
-  let baseDeltaX = findBaseDeltaX(
-    amountX,
-    minDeltaId,
-    maxDeltaId,
+  const minXDeltaId = startDeltaIdAskSide;
+  const maxXDeltaId = maxDeltaId;
+  const amountXInBins = toAmountIntoBins(
+    activeId,
+    minXDeltaId,
+    maxXDeltaId,
+    deltaX,
+    new BN15(0),
+    x0,
+    new BN15(0),
     binStep,
-    activeId
+    favorXInActiveBin
   );
-  const x0 = minDeltaId.neg().mul(baseDeltaX).add(baseDeltaX);
-  while (true) {
-    const amountInBins = getAmountInBinsAskSide(
-      activeId,
-      binStep,
-      minDeltaId,
-      maxDeltaId,
-      baseDeltaX,
-      x0
+  const totalAmountXInQuote = amountXInBins.reduce((acc, bin) => {
+    const price = getPriceOfBinByBinId(
+      bin.binId.toNumber(),
+      binStep.toNumber()
     );
-    const totalAmountX = amountInBins.reduce((acc, { amountX: amountX2 }) => {
-      return acc.add(amountX2);
-    }, new BN15(0));
-    if (totalAmountX.gt(amountX)) {
-      baseDeltaX = baseDeltaX.sub(new BN15(1));
-    } else {
-      return {
-        base: x0,
-        delta: baseDeltaX
-      };
-    }
-  }
+    return acc.add(price.mul(new Decimal7(bin.amountX.toString())));
+  }, new Decimal7(0));
+  const totalAmountXInQuoteBN = new BN15(totalAmountXInQuote.floor().toString());
+  const minYDeltaId = minDeltaId;
+  const maxYDeltaId = startDeltaIdAskSide.subn(1);
+  return builder.suggestBalancedYParametersFromX(
+    activeId,
+    binStep,
+    favorXInActiveBin,
+    minYDeltaId,
+    maxYDeltaId,
+    totalAmountXInQuoteBN
+  );
 }
-var BidAskStrategyParameterBuilder = class {
-  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-    return findX0AndDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId);
-  }
-  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
-    return findY0AndDeltaY(amountY, minDeltaId, maxDeltaId, activeId);
+function buildLiquidityStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, favorXInActiveId, activeId, strategyParameterBuilder) {
+  if (minDeltaId.gt(maxDeltaId)) {
+    return {
+      x0: new BN15(0),
+      y0: new BN15(0),
+      deltaX: new BN15(0),
+      deltaY: new BN15(0)
+    };
   }
-  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
-    const deltaX = amountY.div(
-      maxDeltaId.addn(1).mul(maxDeltaId.addn(2)).divn(2)
-    );
-    const x0 = minDeltaId.neg().mul(deltaX).add(deltaX);
-    const totalAmountX = toAmountIntoBins(
-      activeId,
+  const depositOnlyY = maxDeltaId.lt(new BN15(0)) || maxDeltaId.isZero() && !favorXInActiveId;
+  const depositOnlyX = minDeltaId.gt(new BN15(0)) || minDeltaId.isZero() && favorXInActiveId;
+  if (depositOnlyY) {
+    const { base, delta } = strategyParameterBuilder.findYParameters(
+      amountY,
       minDeltaId,
       maxDeltaId,
-      deltaX,
-      new BN15(0),
-      x0,
-      new BN15(0),
-      binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountX);
-    }, new BN15(0));
+      activeId
+    );
     return {
-      base: x0,
-      delta: deltaX,
-      amountX: totalAmountX
+      x0: new BN15(0),
+      deltaX: new BN15(0),
+      y0: base,
+      deltaY: delta
     };
   }
-  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
-    const m1 = minDeltaId.neg().subn(1);
-    const m2 = maxDeltaId.neg();
-    const a1 = m2.neg().mul(m1.sub(m2).addn(1));
-    const a2 = m1.mul(m1.addn(1)).divn(2);
-    const a3 = m2.mul(m2.subn(1)).divn(2);
-    const a = a1.add(a2.sub(a3));
-    const deltaY = amountXInQuoteValue.div(a);
-    const y0 = deltaY.neg().mul(m2).add(deltaY);
-    const amountY = toAmountIntoBins(
-      activeId,
+  if (depositOnlyX) {
+    const { base, delta } = strategyParameterBuilder.findXParameters(
+      amountX,
       minDeltaId,
       maxDeltaId,
-      new BN15(0),
-      deltaY,
-      new BN15(0),
-      y0,
       binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountY);
-    }, new BN15(0));
+      activeId
+    );
     return {
-      base: y0,
-      delta: deltaY,
-      amountY
+      x0: base,
+      deltaX: delta,
+      y0: new BN15(0),
+      deltaY: new BN15(0)
     };
   }
+  const maxDeltaIdBidSide = favorXInActiveId ? new BN15(-1) : new BN15(0);
+  const minDeltaIdAskSide = favorXInActiveId ? new BN15(0) : new BN15(1);
+  const { base: y0, delta: deltaY } = strategyParameterBuilder.findYParameters(
+    amountY,
+    minDeltaId,
+    maxDeltaIdBidSide,
+    activeId
+  );
+  const { base: x0, delta: deltaX } = strategyParameterBuilder.findXParameters(
+    amountX,
+    minDeltaIdAskSide,
+    maxDeltaId,
+    binStep,
+    activeId
+  );
+  return {
+    x0,
+    deltaX,
+    y0,
+    deltaY
+  };
+}
+
+// src/dlmm/helpers/index.ts
+function chunks(array, size) {
+  return Array.apply(0, new Array(Math.ceil(array.length / size))).map(
+    (_, index) => array.slice(index * size, (index + 1) * size)
+  );
+}
+function range(min, max, mapfn) {
+  const length = max - min + 1;
+  return Array.from({ length }, (_, i) => mapfn(min + i));
+}
+async function chunkedFetchMultiplePoolAccount(program, pks, chunkSize = 100) {
+  const accounts = (await Promise.all(
+    chunks(pks, chunkSize).map(
+      (chunk) => program.account.lbPair.fetchMultiple(chunk)
+    )
+  )).flat();
+  return accounts.filter(Boolean);
+}
+async function chunkedFetchMultipleBinArrayBitmapExtensionAccount(program, pks, chunkSize = 100) {
+  const accounts = (await Promise.all(
+    chunks(pks, chunkSize).map(
+      (chunk) => program.account.binArrayBitmapExtension.fetchMultiple(chunk)
+    )
+  )).flat();
+  return accounts;
+}
+function getOutAmount(bin, inAmount, swapForY) {
+  return swapForY ? mulShr(inAmount, bin.price, SCALE_OFFSET, 1 /* Down */) : shlDiv(inAmount, bin.price, SCALE_OFFSET, 1 /* Down */);
+}
+async function getTokenDecimals(conn, mint) {
+  const token = await getMint(conn, mint);
+  return await token.decimals;
+}
+var getOrCreateATAInstruction = async (connection, tokenMint, owner, programId, payer = owner, allowOwnerOffCurve = true) => {
+  programId = programId ?? TOKEN_PROGRAM_ID3;
+  const toAccount = getAssociatedTokenAddressSync(
+    tokenMint,
+    owner,
+    allowOwnerOffCurve,
+    programId,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+  try {
+    await getAccount(connection, toAccount, connection.commitment, programId);
+    return { ataPubKey: toAccount, ix: void 0 };
+  } catch (e) {
+    if (e instanceof TokenAccountNotFoundError || e instanceof TokenInvalidAccountOwnerError) {
+      const ix = createAssociatedTokenAccountIdempotentInstruction(
+        payer,
+        toAccount,
+        owner,
+        tokenMint,
+        programId,
+        ASSOCIATED_TOKEN_PROGRAM_ID
+      );
+      return { ataPubKey: toAccount, ix };
+    } else {
+      console.error("Error::getOrCreateATAInstruction", e);
+      throw e;
+    }
+  }
+};
+async function getTokenBalance(conn, tokenAccount) {
+  const acc = await getAccount(conn, tokenAccount);
+  return acc.amount;
+}
+var parseLogs = (eventParser, logs) => {
+  if (!logs.length)
+    throw new Error("No logs found");
+  for (const event of eventParser?.parseLogs(logs)) {
+    return event.data;
+  }
+  throw new Error("No events found");
+};
+var wrapSOLInstruction = (from, to, amount) => {
+  return [
+    SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new TransactionInstruction3({
+      keys: [
+        {
+          pubkey: to,
+          isSigner: false,
+          isWritable: true
+        }
+      ],
+      data: Buffer.from(new Uint8Array([17])),
+      programId: TOKEN_PROGRAM_ID3
+    })
+  ];
+};
+var unwrapSOLInstruction = async (owner, allowOwnerOffCurve = true) => {
+  const wSolATAAccount = getAssociatedTokenAddressSync(
+    NATIVE_MINT,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = createCloseAccountInstruction(
+      wSolATAAccount,
+      owner,
+      owner,
+      [],
+      TOKEN_PROGRAM_ID3
+    );
+    return closedWrappedSolInstruction;
+  }
+  return null;
+};
+async function chunkedGetMultipleAccountInfos(connection, pks, chunkSize = 100) {
+  const accountInfos = (await Promise.all(
+    chunks(pks, chunkSize).map(
+      (chunk) => connection.getMultipleAccountsInfo(chunk)
+    )
+  )).flat();
+  return accountInfos;
+}
+var getEstimatedComputeUnitUsageWithBuffer = async (connection, instructions, feePayer, buffer) => {
+  if (!buffer) {
+    buffer = 0.1;
+  }
+  buffer = Math.max(0, buffer);
+  buffer = Math.min(1, buffer);
+  const estimatedComputeUnitUsage = await getSimulationComputeUnits(
+    connection,
+    instructions,
+    feePayer,
+    []
+  );
+  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
+  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
+    extraComputeUnitBuffer = MAX_CU_BUFFER;
+  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
+    extraComputeUnitBuffer = MIN_CU_BUFFER;
+  }
+  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
+};
+var getEstimatedComputeUnitIxWithBuffer = async (connection, instructions, feePayer, buffer) => {
+  const units = await getEstimatedComputeUnitUsageWithBuffer(
+    connection,
+    instructions,
+    feePayer,
+    buffer
+  ).catch((error) => {
+    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
+    return 14e5;
+  });
+  return ComputeBudgetProgram2.setComputeUnitLimit({ units });
 };
-
-// src/dlmm/helpers/rebalance/liquidity_strategy/curve.ts
-import BN16 from "bn.js";
-function findBaseY0(amountY, minDeltaId, maxDeltaId) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN16(0))) {
-    return new BN16(0);
-  }
-  if (minDeltaId.eq(maxDeltaId)) {
-    return amountY;
-  }
-  const m1 = minDeltaId.neg();
-  const m2 = maxDeltaId.neg();
-  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)));
-  return amountY.div(a);
+function createProgram(connection, opt) {
+  const cluster = opt?.cluster || "mainnet-beta";
+  const provider = new AnchorProvider(
+    connection,
+    {},
+    AnchorProvider.defaultOptions()
+  );
+  return new Program2(
+    { ...dlmm_default, address: LBCLMM_PROGRAM_IDS[cluster] },
+    provider
+  );
 }
-function findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
-    return {
-      base: new BN16(0),
-      delta: new BN16(0)
-    };
-  }
-  let baseY0 = findBaseY0(amountY, minDeltaId, maxDeltaId);
-  while (true) {
-    const deltaY = baseY0.neg().div(minDeltaId.neg().addn(1));
-    const amountInBins = getAmountInBinsBidSide(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      deltaY,
-      baseY0
-    );
-    const totalAmountY = amountInBins.reduce((acc, { amountY: amountY2 }) => {
-      return acc.add(amountY2);
-    }, new BN16(0));
-    if (totalAmountY.gt(amountY)) {
-      baseY0 = baseY0.sub(new BN16(1));
-    } else {
-      return {
-        base: baseY0,
-        delta: deltaY
-      };
-    }
-  }
+function decodeAccount(program, accountName, buffer) {
+  return program.coder.accounts.decode(accountName, buffer);
 }
-function findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN16(0))) {
-    return new BN16(0);
+function getAccountDiscriminator(accountName) {
+  return dlmm_default.accounts.find(
+    (acc) => acc.name.toLowerCase() === accountName.toLowerCase()
+  )?.discriminator;
+}
+function capSlippagePercentage(slippage) {
+  if (slippage > 100) {
+    slippage = 100;
   }
-  let b = new BN16(0);
-  let c = new BN16(0);
-  let m1 = minDeltaId;
-  let m2 = maxDeltaId;
-  for (let m = m1.toNumber(); m <= m2.toNumber(); m++) {
-    const binId = activeId.addn(m);
-    const pm = getQPriceFromId(binId.neg(), binStep);
-    b = b.add(pm);
-    const cDelta = new BN16(m).mul(pm).div(m2);
-    c = c.add(cDelta);
+  if (slippage < 0) {
+    slippage = 0;
   }
-  return amountX.shln(SCALE_OFFSET).div(b.sub(c));
+  return slippage;
 }
-function findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN16(0)) || amountX.isZero()) {
-    return {
-      base: new BN16(0),
-      delta: new BN16(0)
-    };
+
+// src/dlmm/helpers/accountFilters.ts
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
+var presetParameter2BinStepFilter = (binStep) => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(binStep.toArrayLike(Buffer, "le", 2)),
+      offset: 8
+    }
+  };
+};
+var presetParameter2BaseFactorFilter = (baseFactor) => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(baseFactor.toArrayLike(Buffer, "le", 2)),
+      offset: 8 + 2
+    }
+  };
+};
+var presetParameter2BaseFeePowerFactor = (baseFeePowerFactor) => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(baseFeePowerFactor.toArrayLike(Buffer, "le", 1)),
+      offset: 8 + 22
+    }
+  };
+};
+var binArrayLbPairFilter = (lbPair) => {
+  return {
+    memcmp: {
+      bytes: lbPair.toBase58(),
+      offset: 8 + 16
+    }
+  };
+};
+var positionOwnerFilter = (owner) => {
+  return {
+    memcmp: {
+      bytes: owner.toBase58(),
+      offset: 8 + 32
+    }
+  };
+};
+var positionLbPairFilter = (lbPair) => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(lbPair.toBuffer()),
+      offset: 8
+    }
+  };
+};
+var positionV2Filter = () => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(Buffer.from(getAccountDiscriminator("positionV2"))),
+      offset: 0
+    }
+  };
+};
+
+// src/dlmm/helpers/positions/index.ts
+import BN18 from "bn.js";
+
+// src/dlmm/helpers/positions/wrapper.ts
+import BN17 from "bn.js";
+function combineBaseAndExtendedPositionBinData(base, extended) {
+  const combinedLiquidityShares = base.liquidityShares;
+  const combinedRewardInfos = base.rewardInfos;
+  const combinedFeeInfos = base.feeInfos;
+  for (const binData of extended) {
+    combinedLiquidityShares.push(binData.liquidityShare);
+    combinedRewardInfos.push(binData.rewardInfo);
+    combinedFeeInfos.push(binData.feeInfo);
   }
-  let baseX0 = findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId);
-  const deltaX = baseX0.neg().div(maxDeltaId);
-  while (true) {
-    const amountInBins = getAmountInBinsAskSide(
-      activeId,
-      binStep,
-      minDeltaId,
-      maxDeltaId,
-      deltaX,
-      baseX0
+  return {
+    liquidityShares: combinedLiquidityShares,
+    rewardInfos: combinedRewardInfos,
+    feeInfos: combinedFeeInfos
+  };
+}
+function wrapPosition(program, key, account) {
+  const disc = account.data.subarray(0, 8);
+  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
+    const state = decodeAccount(
+      program,
+      "positionV2",
+      account.data
     );
-    const totalAmountX = amountInBins.reduce((acc, { amountX: amountX2 }) => {
-      return acc.add(amountX2);
-    }, new BN16(0));
-    if (totalAmountX.gt(amountX)) {
-      baseX0 = baseX0.sub(new BN16(1));
-    } else {
-      return {
-        base: baseX0,
-        delta: deltaX
-      };
-    }
+    const extended = decodeExtendedPosition(
+      state,
+      program,
+      account.data.subarray(8 + POSITION_MIN_SIZE)
+    );
+    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
+      state,
+      extended
+    );
+    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
+  } else {
+    throw new Error("Unknown position account");
   }
 }
-var CurveStrategyParameterBuilder = class {
-  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-    return findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+var PositionV2Wrapper = class {
+  constructor(positionAddress, inner, extended, combinedPositionBinData) {
+    this.positionAddress = positionAddress;
+    this.inner = inner;
+    this.extended = extended;
+    this.combinedPositionBinData = combinedPositionBinData;
   }
-  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
-    return findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId);
+  address() {
+    return this.positionAddress;
   }
-  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
-    const x0 = amountY.muln(2).div(maxDeltaId.addn(1));
-    const deltaX = x0.neg().div(maxDeltaId);
-    const totalAmountX = toAmountIntoBins(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      deltaX,
-      new BN16(0),
-      x0,
-      new BN16(0),
-      binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountX);
-    }, new BN16(0));
-    return {
-      base: x0,
-      delta: deltaX,
-      amountX: totalAmountX
-    };
+  totalClaimedRewards() {
+    return this.inner.totalClaimedRewards;
   }
-  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
-    const m1 = minDeltaId.neg();
-    const m2 = maxDeltaId.neg();
-    const a1 = m1.sub(m2).addn(1);
-    const a2 = m1.mul(m1.addn(1)).divn(2);
-    const a3 = m2.mul(m2.subn(1)).divn(2);
-    const a = m1.sub(a3.sub(a2)).div(m1);
-    const y0 = amountXInQuoteValue.div(a);
-    const deltaY = y0.neg().div(m1);
-    const amountY = toAmountIntoBins(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      new BN16(0),
-      deltaY,
-      new BN16(0),
-      y0,
-      binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountY);
-    }, new BN16(0));
-    return {
-      base: y0,
-      delta: deltaY,
-      amountY
-    };
+  feeOwner() {
+    return this.inner.feeOwner;
   }
-};
-
-// src/dlmm/helpers/rebalance/liquidity_strategy/spot.ts
-import BN17 from "bn.js";
-function findY0(amountY, minDeltaId, maxDeltaId) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN17(0)) || amountY.isZero()) {
-    return new BN17(0);
+  lockReleasePoint() {
+    return this.inner.lockReleasePoint;
   }
-  const m1 = minDeltaId.neg();
-  const m2 = maxDeltaId.neg();
-  const delta = m1.sub(m2).addn(1);
-  return amountY.div(delta);
-}
-function findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  let totalWeight = new BN17(0);
-  const minBinId = activeId.add(minDeltaId);
-  const maxBinId = activeId.add(maxDeltaId);
-  let baseFactor = getQPriceBaseFactor(binStep);
-  let basePrice = getQPriceFromId(maxBinId.neg(), binStep);
-  for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
-    totalWeight = totalWeight.add(basePrice);
-    basePrice = basePrice.mul(baseFactor).shrn(SCALE_OFFSET);
+  operator() {
+    return this.inner.operator;
   }
-  return amountX.shln(SCALE_OFFSET).div(totalWeight);
-}
-function findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN17(0)) || amountX.isZero()) {
-    return new BN17(0);
+  totalClaimedFeeYAmount() {
+    return this.inner.totalClaimedFeeYAmount;
   }
-  let x0 = findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId);
-  while (true) {
-    const amountInBins = getAmountInBinsAskSide(
-      activeId,
-      binStep,
-      minDeltaId,
-      maxDeltaId,
-      new BN17(0),
-      x0
-    );
-    const totalAmountX = amountInBins.reduce((acc, bin) => {
-      return acc.add(bin.amountX);
-    }, new BN17(0));
-    if (totalAmountX.lt(amountX)) {
-      x0 = x0.add(new BN17(1));
+  totalClaimedFeeXAmount() {
+    return this.inner.totalClaimedFeeXAmount;
+  }
+  lbPair() {
+    return this.inner.lbPair;
+  }
+  lowerBinId() {
+    return new BN17(this.inner.lowerBinId);
+  }
+  upperBinId() {
+    return new BN17(this.inner.upperBinId);
+  }
+  liquidityShares() {
+    return this.combinedPositionBinData.liquidityShares;
+  }
+  rewardInfos() {
+    return this.combinedPositionBinData.rewardInfos;
+  }
+  feeInfos() {
+    return this.combinedPositionBinData.feeInfos;
+  }
+  lastUpdatedAt() {
+    return this.inner.lastUpdatedAt;
+  }
+  getBinArrayIndexesCoverage() {
+    const isExtended = this.extended.length > 0;
+    if (isExtended) {
+      return getBinArrayIndexesCoverage(this.lowerBinId(), this.upperBinId());
     } else {
-      x0 = x0.sub(new BN17(1));
-      return x0;
+      const lowerBinArrayIndex = binIdToBinArrayIndex(this.lowerBinId());
+      const upperBinArrayIndex = lowerBinArrayIndex.add(new BN17(1));
+      return [lowerBinArrayIndex, upperBinArrayIndex];
     }
   }
-}
-var SpotStrategyParameterBuilder = class {
-  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-    return {
-      base: findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId),
-      delta: new BN17(0)
-    };
+  getBinArrayKeysCoverage(programId) {
+    return this.getBinArrayIndexesCoverage().map(
+      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
+    );
   }
-  findYParameters(amountY, minDeltaId, maxDeltaId, _activeId) {
-    return {
-      base: findY0(amountY, minDeltaId, maxDeltaId),
-      delta: new BN17(0)
-    };
+  version() {
+    return 1 /* V2 */;
   }
-  suggestBalancedXParametersFromY(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountY) {
-    const x0 = amountY.div(maxDeltaId.addn(1));
-    const totalAmountX = toAmountIntoBins(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      new BN17(0),
-      new BN17(0),
-      x0,
-      new BN17(0),
-      binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountX);
-    }, new BN17(0));
-    return {
-      base: new BN17(x0.toString()),
-      delta: new BN17(0),
-      amountX: totalAmountX
-    };
+  owner() {
+    return this.inner.owner;
   }
-  suggestBalancedYParametersFromX(activeId, binStep, favorXInActiveBin, minDeltaId, maxDeltaId, amountXInQuoteValue) {
-    const y0 = amountXInQuoteValue.div(maxDeltaId.sub(minDeltaId).addn(1));
-    const amountY = toAmountIntoBins(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      new BN17(0),
-      new BN17(0),
-      new BN17(0),
-      y0,
-      binStep,
-      favorXInActiveBin
-    ).reduce((acc, bin) => {
-      return acc.add(bin.amountY);
-    }, new BN17(0));
-    return {
-      base: y0,
-      delta: new BN17(0),
-      amountY
-    };
+  width() {
+    return this.upperBinId().sub(this.lowerBinId()).add(new BN17(1));
   }
 };
 
-// src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
-import Decimal7 from "decimal.js";
-function getLiquidityStrategyParameterBuilder(strategyType) {
-  switch (strategyType) {
-    case 0 /* Spot */:
-      return new SpotStrategyParameterBuilder();
-    case 1 /* Curve */:
-      return new CurveStrategyParameterBuilder();
-    case 2 /* BidAsk */:
-      return new BidAskStrategyParameterBuilder();
-    default:
-      throw new Error("Strategy not supported");
+// src/dlmm/helpers/positions/index.ts
+function getBinArrayIndexesCoverage(lowerBinId, upperBinId) {
+  const lowerBinArrayIndex = binIdToBinArrayIndex(lowerBinId);
+  const upperBinArrayIndex = binIdToBinArrayIndex(upperBinId);
+  const binArrayIndexes = [];
+  for (let i = lowerBinArrayIndex.toNumber(); i <= upperBinArrayIndex.toNumber(); i++) {
+    binArrayIndexes.push(new BN18(i));
   }
+  return binArrayIndexes;
 }
-function buildLiquidityStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, favorXInActiveId, activeId, strategyParameterBuilder) {
-  if (minDeltaId.gt(maxDeltaId)) {
-    return {
-      x0: new BN18(0),
-      y0: new BN18(0),
-      deltaX: new BN18(0),
-      deltaY: new BN18(0)
-    };
+function getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId) {
+  const binArrayIndexes = getBinArrayIndexesCoverage(lowerBinId, upperBinId);
+  return binArrayIndexes.map((index) => {
+    return deriveBinArray(lbPair, index, programId)[0];
+  });
+}
+function getBinArrayAccountMetasCoverage(lowerBinId, upperBinId, lbPair, programId) {
+  return getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId).map(
+    (key) => {
+      return {
+        pubkey: key,
+        isSigner: false,
+        isWritable: true
+      };
+    }
+  );
+}
+function getPositionLowerUpperBinIdWithLiquidity(position) {
+  const binWithLiquidity = position.positionBinData.filter(
+    (b) => !new BN18(b.binLiquidity).isZero() || !new BN18(b.positionFeeXAmount.toString()).isZero() || !new BN18(b.positionFeeYAmount.toString()).isZero() || !new BN18(b.positionRewardAmount[0].toString()).isZero() || !new BN18(b.positionRewardAmount[1].toString()).isZero()
+  );
+  return binWithLiquidity.length > 0 ? {
+    lowerBinId: new BN18(binWithLiquidity[0].binId),
+    upperBinId: new BN18(binWithLiquidity[binWithLiquidity.length - 1].binId)
+  } : null;
+}
+function isPositionNoFee(position) {
+  return position.feeX.isZero() && position.feeY.isZero();
+}
+function isPositionNoReward(position) {
+  return position.rewardOne.isZero() && position.rewardTwo.isZero();
+}
+function chunkBinRange(minBinId, maxBinId) {
+  const chunkedBinRange = [];
+  let startBinId = minBinId;
+  while (startBinId <= maxBinId) {
+    const endBinId = Math.min(
+      startBinId + DEFAULT_BIN_PER_POSITION.toNumber() - 1,
+      maxBinId
+    );
+    chunkedBinRange.push({
+      lowerBinId: startBinId,
+      upperBinId: endBinId
+    });
+    startBinId += DEFAULT_BIN_PER_POSITION.toNumber();
   }
-  const depositOnlyY = maxDeltaId.lt(new BN18(0)) || maxDeltaId.isZero() && !favorXInActiveId;
-  const depositOnlyX = minDeltaId.gt(new BN18(0)) || minDeltaId.isZero() && favorXInActiveId;
-  if (depositOnlyY) {
-    const { base, delta } = strategyParameterBuilder.findYParameters(
-      amountY,
-      minDeltaId,
-      maxDeltaId,
-      activeId
+  return chunkedBinRange;
+}
+async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
+  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
+  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
+  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
+    return 0;
+  } else {
+    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
+      DEFAULT_BIN_PER_POSITION
     );
-    return {
-      x0: new BN18(0),
-      deltaX: new BN18(0),
-      y0: base,
-      deltaY: delta
-    };
+    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
+    const [minimumLamports, rentExemptionLamports] = await Promise.all([
+      connection.getMinimumBalanceForRentExemption(0),
+      connection.getMinimumBalanceForRentExemption(expandSize)
+    ]);
+    return rentExemptionLamports - minimumLamports;
   }
-  if (depositOnlyX) {
-    const { base, delta } = strategyParameterBuilder.findXParameters(
-      amountX,
-      minDeltaId,
-      maxDeltaId,
-      binStep,
-      activeId
+}
+function getExtendedPositionBinCount(minBinId, maxBinId) {
+  const width = maxBinId.sub(minBinId).addn(1);
+  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
+  return extended.lte(new BN18(0)) ? new BN18(0) : extended;
+}
+function decodeExtendedPosition(base, program, bytes) {
+  const width = base.upperBinId - base.lowerBinId + 1;
+  const extendedWidth = width - DEFAULT_BIN_PER_POSITION.toNumber();
+  const extendedPosition = [];
+  for (let i = 0; i < extendedWidth; i++) {
+    const offset = i * POSITION_BIN_DATA_SIZE;
+    const data = bytes.subarray(offset, offset + POSITION_BIN_DATA_SIZE);
+    const decodedPositionBinData = program.coder.types.decode(
+      // TODO: Find a type safe way
+      "positionBinData",
+      data
     );
-    return {
-      x0: base,
-      deltaX: delta,
-      y0: new BN18(0),
-      deltaY: new BN18(0)
-    };
+    extendedPosition.push(decodedPositionBinData);
   }
-  const maxDeltaIdBidSide = favorXInActiveId ? new BN18(-1) : new BN18(0);
-  const minDeltaIdAskSide = favorXInActiveId ? new BN18(0) : new BN18(1);
-  const { base: y0, delta: deltaY } = strategyParameterBuilder.findYParameters(
-    amountY,
-    minDeltaId,
-    maxDeltaIdBidSide,
-    activeId
-  );
-  const { base: x0, delta: deltaX } = strategyParameterBuilder.findXParameters(
-    amountX,
-    minDeltaIdAskSide,
-    maxDeltaId,
-    binStep,
-    activeId
-  );
-  return {
-    x0,
-    deltaX,
-    y0,
-    deltaY
-  };
+  return extendedPosition;
 }
 
 // src/dlmm/helpers/rebalance/strategy/balanced.ts
@@ -19396,6 +19545,7 @@ export {
   PairStatus,
   PairType,
   PositionVersion,
+  RebalancePosition,
   ResizeSide,
   SCALE,
   SCALE_OFFSET,
@@ -19410,6 +19560,7 @@ export {
   autoFillYByStrategy,
   autoFillYByWeight,
   binIdToBinArrayIndex,
+  buildLiquidityStrategyParameters,
   calculateBidAskDistribution,
   calculateNormalDistribution,
   calculateSpotDistribution,
@@ -19446,6 +19597,9 @@ export {
   fromWeightDistributionToAmount,
   fromWeightDistributionToAmountOneSide,
   getAccountDiscriminator,
+  getAmountInBinsAskSide,
+  getAmountInBinsBidSide,
+  getAutoFillAmountByRebalancedPosition,
   getBaseFee,
   getBinArrayLowerUpperBinId,
   getBinArraysRequiredByPositionRange,
@@ -19453,9 +19607,11 @@ export {
   getBinIdIndexInBinArray,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
+  getLiquidityStrategyParameterBuilder,
   getOrCreateATAInstruction,
   getOutAmount,
   getPriceOfBinByBinId,
+  getRebalanceBinArrayIndexesAndBitmapCoverage,
   getTokenBalance,
   getTokenDecimals,
   getTokenProgramId,
@@ -19466,11 +19622,14 @@ export {
   isOverflowDefaultBinArrayBitmap,
   parseLogs,
   range,
+  suggestBalancedXParametersFromY,
+  suggestBalancedYParametersFromX,
   swapExactInQuoteAtBin,
   swapExactOutQuoteAtBin,
   toAmountAskSide,
   toAmountBidSide,
   toAmountBothSide,
+  toAmountIntoBins,
   toAmountsBothSideByStrategy,
   toStrategyParameters,
   toWeightDistribution,