@meteora-ag/dlmm 1.6.0-rc.17 → 1.6.0-rc.19

package/dist/index.mjs

@@ -19,7 +19,7 @@ import {
   SystemProgram as SystemProgram2,
   Transaction
 } from "@solana/web3.js";
-import Decimal7 from "decimal.js";
+import Decimal8 from "decimal.js";
 
 // src/dlmm/constants/index.ts
 import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
@@ -11779,1594 +11779,1861 @@ 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 (wSolATAAccount) {
-    const closedWrappedSolInstruction = createCloseAccountInstruction(
-      wSolATAAccount,
-      owner,
-      owner,
-      [],
-      TOKEN_PROGRAM_ID3
+  if (onlyDepositToAskSide(minDeltaId, favorXInActiveBin)) {
+    return getAmountInBinsAskSide(
+      activeId,
+      binStep,
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      x0
     );
-    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,
-    []
+  const [bidSideEndDeltaId, askSideStartDeltaId] = favorXInActiveBin ? [-1, 0] : [0, 1];
+  const amountInBinsBidSide = getAmountInBinsBidSide(
+    activeId,
+    minDeltaId,
+    new BN11(bidSideEndDeltaId),
+    deltaY,
+    y0
   );
-  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
+  const amountInBinsAskSide = getAmountInBinsAskSide(
+    activeId,
+    binStep,
+    new BN11(askSideStartDeltaId),
+    maxDeltaId,
+    deltaX,
+    x0
   );
+  return amountInBinsBidSide.concat(amountInBinsAskSide);
 }
-function decodeAccount(program, accountName, buffer) {
-  return program.coder.accounts.decode(accountName, buffer);
+function getLiquidity(x, y, price) {
+  const px = price.mul(x);
+  const shly = y.shln(SCALE_OFFSET);
+  return px.add(shly);
 }
-function getAccountDiscriminator(accountName) {
-  return dlmm_default.accounts.find(
-    (acc) => acc.name.toLowerCase() === accountName.toLowerCase()
-  )?.discriminator;
+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 BN11(2)));
+  }
+  return new BN11(0);
 }
-function capSlippagePercentage(slippage) {
-  if (slippage > 100) {
-    slippage = 100;
+function simulateDepositBin(binId, binStep, amountX, amountY, bin) {
+  if (!bin) {
+    return {
+      amountXIntoBin: amountX,
+      amountYIntoBin: amountY
+    };
   }
-  if (slippage < 0) {
-    slippage = 0;
+  const price = getQPriceFromId(binId, binStep);
+  const inLiquidity = getLiquidity(amountX, amountY, price);
+  const binLiquidity = getLiquidity(bin.amountX, bin.amountY, price);
+  if (bin.liquiditySupply.isZero()) {
+    return {
+      amountXIntoBin: amountX,
+      amountYIntoBin: amountY
+    };
   }
-  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);
+  const liquidityShare = inLiquidity.mul(bin.liquiditySupply).div(binLiquidity);
+  const updatedBinXAmount = bin.amountX.add(amountX);
+  const updatedBinYAmount = bin.amountY.add(amountY);
+  const updatedBinSupply = bin.liquiditySupply.add(liquidityShare);
+  let amountXIntoBin = liquidityShare.mul(
+    updatedBinXAmount.div(updatedBinSupply)
+  );
+  let amountYIntoBin = liquidityShare.mul(
+    updatedBinYAmount.div(updatedBinSupply)
+  );
+  if (amountXIntoBin.gt(amountX)) {
   }
   return {
-    liquidityShares: combinedLiquidityShares,
-    rewardInfos: combinedRewardInfos,
-    feeInfos: combinedFeeInfos
+    amountXIntoBin,
+    amountYIntoBin
   };
 }
-function wrapPosition(program, key, account) {
-  const disc = account.data.subarray(0, 8);
-  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
-    const state = decodeAccount(
+var RebalancePosition = class {
+  address;
+  lowerBinId;
+  upperBinId;
+  lbPair;
+  owner;
+  shouldClaimFee;
+  shouldClaimReward;
+  rebalancePositionBinData;
+  activeBin;
+  currentTimestamp;
+  constructor(positionAddress, positionData, lbPair, activeBin, shouldClaimFee, shouldClaimReward, currentTimestamp) {
+    this.address = positionAddress;
+    this.rebalancePositionBinData = toRebalancePositionBinData(positionData);
+    this.lowerBinId = new BN11(positionData.lowerBinId);
+    this.upperBinId = new BN11(positionData.upperBinId);
+    this.lbPair = lbPair;
+    this.shouldClaimFee = shouldClaimFee;
+    this.shouldClaimReward = shouldClaimReward;
+    this.owner = positionData.owner;
+    this.activeBin = activeBin;
+    this.currentTimestamp = currentTimestamp;
+  }
+  static async create(params) {
+    const {
       program,
-      "positionV2",
-      account.data
+      positionAddress,
+      pairAddress,
+      positionData,
+      shouldClaimFee,
+      shouldClaimReward
+    } = params;
+    const [lbPairAccount, clockAccount] = await program.provider.connection.getMultipleAccountsInfo([
+      pairAddress,
+      SYSVAR_CLOCK_PUBKEY
+    ]);
+    const lbPair = decodeAccount(program, "lbPair", lbPairAccount.data);
+    const clock = ClockLayout.decode(clockAccount.data);
+    const activeBinArrayIdx = binIdToBinArrayIndex(new BN11(lbPair.activeId));
+    const [activeBinArrayPubkey] = deriveBinArray(
+      pairAddress,
+      activeBinArrayIdx,
+      program.programId
     );
-    const extended = decodeExtendedPosition(
-      state,
-      program,
-      account.data.subarray(8 + POSITION_MIN_SIZE)
+    const activeBinArrayState = await program.account.binArray.fetch(
+      activeBinArrayPubkey
     );
-    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
-      state,
-      extended
+    const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(activeBinArrayIdx);
+    const idx = getBinIdIndexInBinArray(
+      new BN11(lbPair.activeId),
+      lowerBinId,
+      upperBinId
+    );
+    const activeBin = activeBinArrayState[idx.toNumber()];
+    return new RebalancePosition(
+      positionAddress,
+      positionData,
+      lbPair,
+      activeBin,
+      shouldClaimFee,
+      shouldClaimReward,
+      clock.unixTimestamp
     );
-    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;
+  _simulateDeposit(binStep, tokenXDecimal, tokenYDecimal, deposits, simulatedWithdrawResult) {
+    const { liquidityAndFeeXWithdrawn, liquidityAndFeeYWithdrawn } = simulatedWithdrawResult;
+    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 BN11(depositMinBinId),
+        new BN11(depositMaxBinId),
+        binStep,
+        tokenXDecimal,
+        tokenYDecimal
+      );
+    }
+    let totalAmountXDeposited = new BN11(0);
+    let totalAmountYDeposited = new BN11(0);
+    const addLiquidityParam = [];
+    for (const {
+      x0,
+      y0,
+      favorXInActiveBin,
+      deltaX,
+      deltaY,
+      minDeltaId,
+      maxDeltaId
+    } of deposits) {
+      const params = buildBitFlagAndNegateStrategyParameters(
+        x0,
+        y0,
+        deltaX,
+        deltaY
+      );
+      addLiquidityParam.push({
+        minDeltaId: minDeltaId.toNumber(),
+        maxDeltaId: maxDeltaId.toNumber(),
+        x0: params.x0,
+        y0: params.y0,
+        deltaX: params.deltaX,
+        deltaY: params.deltaY,
+        bitFlag: params.bitFlag,
+        padding: Array(16).fill(0),
+        favorXInActiveId: favorXInActiveBin
+      });
+      const amountIntoBins = toAmountIntoBins(
+        activeId,
+        minDeltaId,
+        maxDeltaId,
+        deltaX,
+        deltaY,
+        x0,
+        y0,
+        binStep,
+        favorXInActiveBin
+      );
+      for (const { binId, amountX, amountY } of amountIntoBins) {
+        totalAmountXDeposited = totalAmountXDeposited.add(amountX);
+        totalAmountYDeposited = totalAmountYDeposited.add(amountY);
+        const idx = this.rebalancePositionBinData.findIndex(
+          (data) => data.binId == binId.toNumber()
+        );
+        if (binId.eq(activeId)) {
+          const vParameters3 = Object.assign({}, this.lbPair.vParameters);
+          const sParameters3 = Object.assign({}, this.lbPair.parameters);
+          DLMM.updateReference(
+            activeId.toNumber(),
+            vParameters3,
+            sParameters3,
+            this.currentTimestamp.toNumber()
+          );
+          DLMM.updateVolatilityAccumulator(
+            vParameters3,
+            sParameters3,
+            activeId.toNumber()
+          );
+          const { amountXIntoBin, amountYIntoBin } = simulateDepositBin(
+            binId,
+            binStep,
+            amountX,
+            amountY,
+            this.activeBin
+          );
+          const feeY = computeCompositionFee(
+            binStep,
+            sParameters3,
+            vParameters3,
+            amountXIntoBin,
+            amountX,
+            amountYIntoBin,
+            amountY
+          );
+          const feeX = computeCompositionFee(
+            binStep,
+            sParameters3,
+            vParameters3,
+            amountYIntoBin,
+            amountY,
+            amountXIntoBin,
+            amountX
+          );
+          const amountXIntoBinExcludeFee = amountXIntoBin.sub(feeX);
+          const amountYIntoBinExcludeFee = amountYIntoBin.sub(feeY);
+          this.rebalancePositionBinData[idx].amountX = this.rebalancePositionBinData[idx].amountX.add(
+            amountXIntoBinExcludeFee
+          );
+          this.rebalancePositionBinData[idx].amountY = this.rebalancePositionBinData[idx].amountY.add(
+            amountYIntoBinExcludeFee
+          );
+        } else {
+          this.rebalancePositionBinData[idx].amountX = this.rebalancePositionBinData[idx].amountX.add(amountX);
+          this.rebalancePositionBinData[idx].amountY = this.rebalancePositionBinData[idx].amountY.add(amountY);
+        }
+      }
+    }
+    let actualTotalAmountXDeposited = totalAmountXDeposited;
+    let actualTotalAmountYDeposited = totalAmountYDeposited;
+    let actualLiquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn;
+    let actualLiquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn;
+    if (actualTotalAmountXDeposited.gt(actualLiquidityAndFeeXWithdrawn)) {
+      actualTotalAmountXDeposited = actualTotalAmountXDeposited.sub(
+        actualLiquidityAndFeeXWithdrawn
+      );
+      actualLiquidityAndFeeXWithdrawn = new BN11(0);
+    } else {
+      actualLiquidityAndFeeXWithdrawn = actualLiquidityAndFeeXWithdrawn.sub(
+        actualTotalAmountXDeposited
+      );
+      actualTotalAmountXDeposited = new BN11(0);
+    }
+    if (actualTotalAmountYDeposited.gt(actualLiquidityAndFeeYWithdrawn)) {
+      actualTotalAmountYDeposited = actualTotalAmountYDeposited.sub(
+        actualLiquidityAndFeeYWithdrawn
+      );
+      actualLiquidityAndFeeYWithdrawn = new BN11(0);
+    } else {
+      actualLiquidityAndFeeYWithdrawn = actualLiquidityAndFeeYWithdrawn.sub(
+        actualTotalAmountYDeposited
+      );
+      actualTotalAmountYDeposited = new BN11(0);
+    }
+    return {
+      result: {
+        totalAmountXDeposited,
+        totalAmountYDeposited,
+        actualLiquidityAndFeeXWithdrawn,
+        actualLiquidityAndFeeYWithdrawn,
+        actualTotalAmountXDeposited,
+        actualTotalAmountYDeposited
+      },
+      depositParams: addLiquidityParam
+    };
   }
-  lowerBinId() {
-    return new BN12(this.inner.lowerBinId);
+  _simulateResize(depositMinBinId, depositMaxBinId, binStep, tokenXDecimal, tokenYDecimal) {
+    const tokenXMultiplier = new Decimal6(10 ** tokenXDecimal.toNumber());
+    const tokenYMultiplier = new Decimal6(10 ** tokenYDecimal.toNumber());
+    const [minBinId, maxBinId] = findMinMaxBinIdWithLiquidity(
+      this.rebalancePositionBinData
+    );
+    const newMinBinId = new BN11(
+      Math.min(depositMinBinId.toNumber(), minBinId ?? Number.MAX_SAFE_INTEGER)
+    );
+    const newMaxBinId = new BN11(
+      Math.max(depositMaxBinId.toNumber(), maxBinId ?? Number.MIN_SAFE_INTEGER)
+    );
+    if (newMinBinId.lt(this.lowerBinId)) {
+      const binCountToExpand = this.lowerBinId.sub(depositMinBinId);
+      for (let i = 1; i <= binCountToExpand.toNumber(); i++) {
+        const binId = this.lowerBinId.subn(i);
+        const price = getPriceOfBinByBinId(
+          binId.toNumber(),
+          binStep.toNumber()
+        );
+        const adjustedPrice = price.mul(tokenXMultiplier).div(tokenYMultiplier);
+        this.rebalancePositionBinData.unshift({
+          binId: binId.toNumber(),
+          price: adjustedPrice.toString(),
+          pricePerToken: adjustedPrice.toString(),
+          amountX: new BN11(0),
+          amountY: new BN11(0),
+          claimableRewardAmount: [new BN11(0), new BN11(0)],
+          claimableFeeXAmount: new BN11(0),
+          claimableFeeYAmount: new BN11(0)
+        });
+      }
+    } else {
+      const binCountToShrink = newMinBinId.sub(this.lowerBinId);
+      for (let i = 1; i <= binCountToShrink.toNumber(); i++) {
+        this.rebalancePositionBinData.shift();
+      }
+    }
+    if (newMaxBinId.gt(this.upperBinId)) {
+      const binCountToExpand = newMaxBinId.sub(this.upperBinId);
+      for (let i = 1; i <= binCountToExpand.toNumber(); i++) {
+        const binId = this.upperBinId.addn(i);
+        const price = getPriceOfBinByBinId(
+          binId.toNumber(),
+          binStep.toNumber()
+        );
+        const adjustedPrice = price.mul(tokenXMultiplier).div(tokenYMultiplier);
+        this.rebalancePositionBinData.push({
+          binId: binId.toNumber(),
+          price: adjustedPrice.toString(),
+          pricePerToken: adjustedPrice.toString(),
+          amountX: new BN11(0),
+          amountY: new BN11(0),
+          claimableRewardAmount: [new BN11(0), new BN11(0)],
+          claimableFeeXAmount: new BN11(0),
+          claimableFeeYAmount: new BN11(0)
+        });
+      }
+    } else {
+      const binCountToShrink = this.upperBinId.sub(newMaxBinId);
+      for (let i = 1; i <= binCountToShrink.toNumber(); i++) {
+        this.rebalancePositionBinData.pop();
+      }
+    }
+    this.lowerBinId = newMinBinId;
+    this.upperBinId = newMaxBinId;
   }
-  upperBinId() {
-    return new BN12(this.inner.upperBinId);
+  _simulateWithdraw(withdraws) {
+    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;
+      const binIds = binRangeToBinIdArray(fromBinId, toBinId).filter(
+        (binId) => binId.gte(this.lowerBinId) && binId.lte(this.upperBinId)
+      );
+      for (const binId of binIds) {
+        const idx = this.rebalancePositionBinData.findIndex(
+          (b) => b.binId === binId.toNumber()
+        );
+        const binData = this.rebalancePositionBinData[idx];
+        const amountXWithdrawn = binData.amountX.mul(bps).divn(BASIS_POINT_MAX);
+        const amountYWithdrawn = binData.amountY.mul(bps).divn(BASIS_POINT_MAX);
+        liquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn.add(amountXWithdrawn);
+        liquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn.add(amountYWithdrawn);
+        binData.amountX = binData.amountX.sub(amountXWithdrawn);
+        binData.amountY = binData.amountY.sub(amountYWithdrawn);
+        if (this.shouldClaimFee) {
+          liquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn.add(
+            binData.claimableFeeXAmount
+          );
+          liquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn.add(
+            binData.claimableFeeYAmount
+          );
+          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 BN11(0);
+          }
+        }
+        this.rebalancePositionBinData[idx] = binData;
+      }
+    }
+    const withdrawParams = withdraws.map(
+      ({ minBinId, maxBinId, bps }) => {
+        return {
+          minBinId: minBinId ? minBinId.toNumber() : null,
+          maxBinId: maxBinId ? maxBinId.toNumber() : null,
+          bps: bps.toNumber(),
+          padding: Array(16).fill(0)
+        };
+      }
+    );
+    return {
+      result: {
+        liquidityAndFeeXWithdrawn,
+        liquidityAndFeeYWithdrawn,
+        rewardsAmountClaimed
+      },
+      withdrawParams
+    };
   }
-  liquidityShares() {
-    return this.combinedPositionBinData.liquidityShares;
+  async simulateRebalance(connection, binStep, tokenXDecimal, tokenYDecimal, withdraws, deposits) {
+    if (withdraws.length == 0 && deposits.length == 0) {
+      throw "No rebalance action";
+    }
+    const activeId = new BN11(this.lbPair.activeId);
+    withdraws = validateAndSortRebalanceWithdraw(withdraws, activeId);
+    deposits = validateAndSortRebalanceDeposit(deposits);
+    const beforeWidth = getPositionWidthWithMinWidth(
+      this.lowerBinId.toNumber(),
+      this.upperBinId.toNumber()
+    );
+    const { withdrawParams, result: withdrawResult } = this._simulateWithdraw(withdraws);
+    const { depositParams, result: depositResult } = this._simulateDeposit(
+      binStep,
+      tokenXDecimal,
+      tokenYDecimal,
+      deposits,
+      withdrawResult
+    );
+    const afterWidth = getPositionWidthWithMinWidth(
+      this.lowerBinId.toNumber(),
+      this.upperBinId.toNumber()
+    );
+    const widthDelta = afterWidth - beforeWidth;
+    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 BN11(rentExemptionLamports).sub(
+        new BN11(minimumLamports)
+      );
+      if (widthDelta > 0) {
+        rentalCostLamports = rentalCostLamports.add(lamportChanges);
+      } else {
+        rentalCostLamports = rentalCostLamports.sub(lamportChanges);
+      }
+    }
+    return {
+      amountXDeposited: depositResult.totalAmountXDeposited,
+      amountYDeposited: depositResult.totalAmountYDeposited,
+      actualAmountXDeposited: depositResult.actualTotalAmountXDeposited,
+      actualAmountYDeposited: depositResult.actualTotalAmountYDeposited,
+      actualAmountXWithdrawn: depositResult.actualLiquidityAndFeeXWithdrawn,
+      actualAmountYWithdrawn: depositResult.actualLiquidityAndFeeYWithdrawn,
+      rewardAmountsClaimed: withdrawResult.rewardsAmountClaimed,
+      withdrawParams,
+      depositParams,
+      rentalCostLamports
+    };
   }
-  rewardInfos() {
-    return this.combinedPositionBinData.rewardInfos;
+  totalAmounts() {
+    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);
+    }
+    return [totalAmountX, totalAmountY];
   }
-  feeInfos() {
-    return this.combinedPositionBinData.feeInfos;
+  totalFeeAmounts() {
+    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);
+    }
+    return [totalFeeXAmount, totalFeeYAmount];
   }
-  lastUpdatedAt() {
-    return this.inner.lastUpdatedAt;
+  totalRewardAmounts() {
+    let totalRewardAmounts = [new BN11(0), new BN11(0)];
+    for (const binData of this.rebalancePositionBinData) {
+      totalRewardAmounts[0] = totalRewardAmounts[0].add(
+        binData.claimableRewardAmount[0]
+      );
+      totalRewardAmounts[1] = totalRewardAmounts[1].add(
+        binData.claimableRewardAmount[1]
+      );
+    }
+    return totalRewardAmounts;
   }
-  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];
+};
+function getPositionWidthWithMinWidth(lowerBinId, upperBinId) {
+  const width = upperBinId - lowerBinId + 1;
+  return Math.max(width, DEFAULT_BIN_PER_POSITION.toNumber());
+}
+function validateAndSortRebalanceDeposit(deposits) {
+  const sortedDeposits = deposits.sort(
+    (a, b) => a.minDeltaId.sub(b.minDeltaId).toNumber()
+  );
+  for (const deposit of deposits) {
+    if (deposit.minDeltaId.gte(deposit.maxDeltaId)) {
+      throw "Invalid minDeltaId or maxDeltaId";
     }
   }
-  getBinArrayKeysCoverage(programId) {
-    return this.getBinArrayIndexesCoverage().map(
-      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
-    );
-  }
-  version() {
-    return 1 /* V2 */;
+  for (let i = 1; i < sortedDeposits.length; i++) {
+    const prevDeposit = sortedDeposits[i - 1];
+    const currDeposit = sortedDeposits[i];
+    if (prevDeposit.maxDeltaId.gte(currDeposit.minDeltaId)) {
+      throw "Overlap deposit bin range";
+    }
   }
-  owner() {
-    return this.inner.owner;
+  return sortedDeposits;
+}
+function validateAndSortRebalanceWithdraw(withdraws, activeId) {
+  const filledWithdraws = [];
+  for (const { minBinId, maxBinId, bps } of withdraws) {
+    if (bps.toNumber() < 0 || bps.toNumber() > BASIS_POINT_MAX) {
+      throw "Invalid bps";
+    }
+    const filledMinBinId = minBinId ?? activeId;
+    const filledMaxBinId = maxBinId ?? activeId;
+    if (filledMinBinId.gt(filledMaxBinId)) {
+      throw "Invalid minBinId or maxBinId";
+    }
+    filledWithdraws.push({
+      minBinId: filledMinBinId,
+      maxBinId: filledMaxBinId,
+      bps
+    });
   }
-  width() {
-    return this.upperBinId().sub(this.lowerBinId()).add(new BN12(1));
+  filledWithdraws.sort((a, b) => {
+    return a.minBinId.sub(b.minBinId).toNumber();
+  });
+  for (let i = 1; i < filledWithdraws.length; i++) {
+    const prev = filledWithdraws[i - 1];
+    const curr = filledWithdraws[i];
+    if (curr.minBinId.lte(prev.maxBinId)) {
+      throw "Overlap withdraw bin range";
+    }
   }
-};
-
-// 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 filledWithdraws;
+}
+function binRangeToBinIdArray(minBinId, maxBinId) {
+  const binIdArray = [];
+  const fromBinId = minBinId.toNumber();
+  const toBinId = maxBinId.toNumber();
+  for (let binId = fromBinId; binId <= toBinId; binId++) {
+    binIdArray.push(new BN11(binId));
   }
-  return binArrayIndexes;
+  return binIdArray;
 }
-function getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId) {
-  const binArrayIndexes = getBinArrayIndexesCoverage(lowerBinId, upperBinId);
-  return binArrayIndexes.map((index) => {
-    return deriveBinArray(lbPair, index, programId)[0];
+function getRebalanceBinArrayIndexesAndBitmapCoverage(adds, removes, activeId, pairAddress, programId) {
+  let indexMap = /* @__PURE__ */ new Map();
+  removes.forEach((value) => {
+    let minBinId = value.minBinId;
+    if (minBinId == null) {
+      minBinId = activeId;
+    }
+    let maxBinId = value.maxBinId;
+    if (maxBinId == null) {
+      maxBinId = activeId;
+    }
+    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 BN11(1));
+      }
+    }
   });
-}
-function getBinArrayAccountMetasCoverage(lowerBinId, upperBinId, lbPair, programId) {
-  return getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId).map(
-    (key) => {
-      return {
-        pubkey: key,
-        isSigner: false,
-        isWritable: true
-      };
+  adds.forEach((value) => {
+    const minBinId = activeId + value.minDeltaId;
+    const maxBinId = activeId + value.maxDeltaId;
+    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 BN11(1));
+      }
     }
+  });
+  const binArrayIndexes = Array.from(indexMap.keys()).map((idx) => new BN11(idx));
+  const requireBitmapExtension = binArrayIndexes.some(
+    (index) => isOverflowDefaultBinArrayBitmap(new BN11(index))
   );
+  return {
+    binArrayIndexes,
+    binArrayBitmap: requireBitmapExtension ? deriveBinArrayBitmapExtension(pairAddress, programId)[0] : programId
+  };
 }
-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();
+
+// src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
+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);
   }
-  return chunkedBinRange;
+  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);
 }
-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
+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 expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
-    const [minimumLamports, rentExemptionLamports] = await Promise.all([
-      connection.getMinimumBalanceForRentExemption(0),
-      connection.getMinimumBalanceForRentExemption(expandSize)
-    ]);
-    return rentExemptionLamports - minimumLamports;
+    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 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 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 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
+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
     );
-    extendedPosition.push(decodedPositionBinData);
+    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
+      };
+    }
   }
-  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();
+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
+    };
   }
-  if (y0.isNeg()) {
-    bitFlag |= 2;
-    y0 = y0.neg();
+  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
+    };
   }
-  if (deltaX.isNeg()) {
-    bitFlag |= 4;
-    deltaX = deltaX.neg();
+};
+
+// 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 (deltaY.isNeg()) {
-    bitFlag |= 8;
-    deltaY = deltaY.neg();
+  if (minDeltaId.eq(maxDeltaId)) {
+    return amountY;
   }
-  return {
-    bitFlag,
-    x0,
-    y0,
-    deltaX,
-    deltaY
-  };
+  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 toRebalancePositionBinData(positionData) {
-  return positionData.positionBinData.map(
-    ({
-      binId,
-      price,
-      pricePerToken,
-      positionXAmount,
-      positionYAmount,
-      positionFeeXAmount,
-      positionFeeYAmount,
-      positionRewardAmount
-    }) => {
+function findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
+    return {
+      base: new BN13(0),
+      delta: new BN13(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 BN13(0));
+    if (totalAmountY.gt(amountY)) {
+      baseY0 = baseY0.sub(new BN13(1));
+    } else {
       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)
+        base: baseY0,
+        delta: deltaY
       };
     }
-  );
+  }
 }
-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);
-    }
+function findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN13(0))) {
+    return new BN13(0);
   }
-  const binIds = Array.from(uniqueBinId);
-  binIds.sort((a, b) => a - b);
-  return binIds;
+  let b = new BN13(0);
+  let c = new BN13(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 BN13(m).mul(pm).div(m2);
+    c = c.add(cDelta);
+  }
+  return amountX.shln(SCALE_OFFSET).div(b.sub(c));
 }
-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;
+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
+      };
     }
   }
-  return [minBinId, maxBinId];
 }
-function onlyDepositToBidSide(maxDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return maxDeltaId.lt(new BN14(0));
+var CurveStrategyParameterBuilder = class {
+  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+    return findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId);
   }
-  return maxDeltaId.lte(new BN14(0));
-}
-function onlyDepositToAskSide(minDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return minDeltaId.gte(new BN14(0));
+  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
+    return findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId);
   }
-  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),
+  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
-    });
+    };
   }
-  return amountInBins;
+};
+
+// 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 getAmountInBinsAskSide(activeId, binStep, minDeltaId, maxDeltaId, deltaX, x0) {
-  const binCount = maxDeltaId.sub(minDeltaId).add(new BN14(1));
+function findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  let totalWeight = new BN14(0);
   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);
+  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 amountInBins;
+  return amountX.shln(SCALE_OFFSET).div(totalWeight);
 }
-function toAmountIntoBins(activeId, minDeltaId, maxDeltaId, deltaX, deltaY, x0, y0, binStep, favorXInActiveBin) {
-  if (onlyDepositToBidSide(maxDeltaId, favorXInActiveBin)) {
-    return getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0);
+function findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
+  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN14(0)) || amountX.isZero()) {
+    return new BN14(0);
   }
-  if (onlyDepositToAskSide(minDeltaId, favorXInActiveBin)) {
-    return getAmountInBinsAskSide(
+  let x0 = findBaseX02(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  while (true) {
+    const amountInBins = 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
+      maxDeltaId,
+      new BN14(0),
+      x0
     );
-    const feeAmount = delta.mul(totalFeeRate);
-    return feeAmount.mul(FEE_PRECISION.add(totalFeeRate)).div(FEE_PRECISION.pow(new BN14(2)));
+    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;
+    }
   }
-  return new BN14(0);
 }
-function simulateDepositBin(binId, binStep, amountX, amountY, bin) {
-  if (!bin) {
+var SpotStrategyParameterBuilder = class {
+  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
     return {
-      amountXIntoBin: amountX,
-      amountYIntoBin: amountY
+      base: findX0(amountX, minDeltaId, maxDeltaId, binStep, activeId),
+      delta: new BN14(0)
     };
   }
-  const price = getQPriceFromId(binId, binStep);
-  const inLiquidity = getLiquidity(amountX, amountY, price);
-  const binLiquidity = getLiquidity(bin.amountX, bin.amountY, price);
-  if (bin.liquiditySupply.isZero()) {
+  findYParameters(amountY, minDeltaId, maxDeltaId, _activeId) {
     return {
-      amountXIntoBin: amountX,
-      amountYIntoBin: amountY
+      base: findY0(amountY, minDeltaId, maxDeltaId),
+      delta: new BN14(0)
     };
   }
-  const liquidityShare = inLiquidity.mul(bin.liquiditySupply).div(binLiquidity);
-  const updatedBinXAmount = bin.amountX.add(amountX);
-  const updatedBinYAmount = bin.amountY.add(amountY);
-  const updatedBinSupply = bin.liquiditySupply.add(liquidityShare);
-  let amountXIntoBin = liquidityShare.mul(
-    updatedBinXAmount.div(updatedBinSupply)
-  );
-  let amountYIntoBin = liquidityShare.mul(
-    updatedBinYAmount.div(updatedBinSupply)
-  );
-  if (amountXIntoBin.gt(amountX)) {
-  }
-  return {
-    amountXIntoBin,
-    amountYIntoBin
-  };
-}
-var RebalancePosition = class {
-  address;
-  lowerBinId;
-  upperBinId;
-  lbPair;
-  owner;
-  shouldClaimFee;
-  shouldClaimReward;
-  rebalancePositionBinData;
-  activeBin;
-  currentTimestamp;
-  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.lbPair = lbPair;
-    this.shouldClaimFee = shouldClaimFee;
-    this.shouldClaimReward = shouldClaimReward;
-    this.owner = positionData.owner;
-    this.activeBin = activeBin;
-    this.currentTimestamp = currentTimestamp;
-  }
-  static async create(params) {
-    const {
-      program,
-      positionAddress,
-      pairAddress,
-      positionData,
-      shouldClaimFee,
-      shouldClaimReward
-    } = params;
-    const [lbPairAccount, clockAccount] = await program.provider.connection.getMultipleAccountsInfo([
-      pairAddress,
-      SYSVAR_CLOCK_PUBKEY
-    ]);
-    const lbPair = decodeAccount(program, "lbPair", lbPairAccount.data);
-    const clock = ClockLayout.decode(clockAccount.data);
-    const activeBinArrayIdx = binIdToBinArrayIndex(new BN14(lbPair.activeId));
-    const [activeBinArrayPubkey] = deriveBinArray(
-      pairAddress,
-      activeBinArrayIdx,
-      program.programId
-    );
-    const activeBinArrayState = await program.account.binArray.fetch(
-      activeBinArrayPubkey
-    );
-    const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(activeBinArrayIdx);
-    const idx = getBinIdIndexInBinArray(
-      new BN14(lbPair.activeId),
-      lowerBinId,
-      upperBinId
-    );
-    const activeBin = activeBinArrayState[idx.toNumber()];
-    return new RebalancePosition(
-      positionAddress,
-      positionData,
-      lbPair,
-      activeBin,
-      shouldClaimFee,
-      shouldClaimReward,
-      clock.unixTimestamp
-    );
-  }
-  _simulateDeposit(binStep, tokenXDecimal, tokenYDecimal, deposits, simulatedWithdrawResult) {
-    const { liquidityAndFeeXWithdrawn, liquidityAndFeeYWithdrawn } = simulatedWithdrawResult;
-    const activeId = new BN14(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),
-        binStep,
-        tokenXDecimal,
-        tokenYDecimal
-      );
-    }
-    let totalAmountXDeposited = new BN14(0);
-    let totalAmountYDeposited = new BN14(0);
-    const addLiquidityParam = [];
-    for (const {
+  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,
-      y0,
-      favorXInActiveBin,
-      deltaX,
-      deltaY,
+      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
-    } of deposits) {
-      const params = buildBitFlagAndNegateStrategyParameters(
-        x0,
-        y0,
-        deltaX,
-        deltaY
-      );
-      addLiquidityParam.push({
-        minDeltaId: minDeltaId.toNumber(),
-        maxDeltaId: maxDeltaId.toNumber(),
-        x0: params.x0,
-        y0: params.y0,
-        deltaX: params.deltaX,
-        deltaY: params.deltaY,
-        bitFlag: params.bitFlag,
-        padding: Array(16).fill(0),
-        favorXInActiveId: favorXInActiveBin
-      });
-      const amountIntoBins = toAmountIntoBins(
-        activeId,
-        minDeltaId,
-        maxDeltaId,
-        deltaX,
-        deltaY,
-        x0,
-        y0,
-        binStep,
-        favorXInActiveBin
-      );
-      for (const { binId, amountX, amountY } of amountIntoBins) {
-        totalAmountXDeposited = totalAmountXDeposited.add(amountX);
-        totalAmountYDeposited = totalAmountYDeposited.add(amountY);
-        const idx = this.rebalancePositionBinData.findIndex(
-          (data) => data.binId == binId.toNumber()
-        );
-        if (binId.eq(activeId)) {
-          const vParameters3 = Object.assign({}, this.lbPair.vParameters);
-          const sParameters3 = Object.assign({}, this.lbPair.parameters);
-          DLMM.updateReference(
-            activeId.toNumber(),
-            vParameters3,
-            sParameters3,
-            this.currentTimestamp.toNumber()
-          );
-          DLMM.updateVolatilityAccumulator(
-            vParameters3,
-            sParameters3,
-            activeId.toNumber()
-          );
-          const { amountXIntoBin, amountYIntoBin } = simulateDepositBin(
-            binId,
-            binStep,
-            amountX,
-            amountY,
-            this.activeBin
-          );
-          const feeY = computeCompositionFee(
-            binStep,
-            sParameters3,
-            vParameters3,
-            amountXIntoBin,
-            amountX,
-            amountYIntoBin,
-            amountY
-          );
-          const feeX = computeCompositionFee(
-            binStep,
-            sParameters3,
-            vParameters3,
-            amountYIntoBin,
-            amountY,
-            amountXIntoBin,
-            amountX
-          );
-          const amountXIntoBinExcludeFee = amountXIntoBin.sub(feeX);
-          const amountYIntoBinExcludeFee = amountYIntoBin.sub(feeY);
-          this.rebalancePositionBinData[idx].amountX = this.rebalancePositionBinData[idx].amountX.add(
-            amountXIntoBinExcludeFee
-          );
-          this.rebalancePositionBinData[idx].amountY = this.rebalancePositionBinData[idx].amountY.add(
-            amountYIntoBinExcludeFee
-          );
-        } else {
-          this.rebalancePositionBinData[idx].amountX = this.rebalancePositionBinData[idx].amountX.add(amountX);
-          this.rebalancePositionBinData[idx].amountY = this.rebalancePositionBinData[idx].amountY.add(amountY);
-        }
-      }
-    }
-    let actualTotalAmountXDeposited = totalAmountXDeposited;
-    let actualTotalAmountYDeposited = totalAmountYDeposited;
-    let actualLiquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn;
-    let actualLiquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn;
-    if (actualTotalAmountXDeposited.gt(actualLiquidityAndFeeXWithdrawn)) {
-      actualTotalAmountXDeposited = actualTotalAmountXDeposited.sub(
-        actualLiquidityAndFeeXWithdrawn
-      );
-      actualLiquidityAndFeeXWithdrawn = new BN14(0);
-    } else {
-      actualLiquidityAndFeeXWithdrawn = actualLiquidityAndFeeXWithdrawn.sub(
-        actualTotalAmountXDeposited
-      );
-      actualTotalAmountXDeposited = new BN14(0);
-    }
-    if (actualTotalAmountYDeposited.gt(actualLiquidityAndFeeYWithdrawn)) {
-      actualTotalAmountYDeposited = actualTotalAmountYDeposited.sub(
-        actualLiquidityAndFeeYWithdrawn
-      );
-      actualLiquidityAndFeeYWithdrawn = new BN14(0);
-    } else {
-      actualLiquidityAndFeeYWithdrawn = actualLiquidityAndFeeYWithdrawn.sub(
-        actualTotalAmountYDeposited
-      );
-      actualTotalAmountYDeposited = new BN14(0);
-    }
+      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 {
-      result: {
-        totalAmountXDeposited,
-        totalAmountYDeposited,
-        actualLiquidityAndFeeXWithdrawn,
-        actualLiquidityAndFeeYWithdrawn,
-        actualTotalAmountXDeposited,
-        actualTotalAmountYDeposited
-      },
-      depositParams: addLiquidityParam
+      base: new BN15(0),
+      delta: new BN15(0),
+      amountX: new BN15(0)
     };
   }
-  _simulateResize(depositMinBinId, depositMaxBinId, binStep, tokenXDecimal, tokenYDecimal) {
-    const tokenXMultiplier = new Decimal6(10 ** tokenXDecimal.toNumber());
-    const tokenYMultiplier = new Decimal6(10 ** tokenYDecimal.toNumber());
-    const [minBinId, maxBinId] = findMinMaxBinIdWithLiquidity(
-      this.rebalancePositionBinData
-    );
-    const newMinBinId = new BN14(
-      Math.min(depositMinBinId.toNumber(), minBinId ?? Number.MAX_SAFE_INTEGER)
-    );
-    const newMaxBinId = new BN14(
-      Math.max(depositMaxBinId.toNumber(), maxBinId ?? Number.MIN_SAFE_INTEGER)
-    );
-    if (newMinBinId.lt(this.lowerBinId)) {
-      const binCountToExpand = this.lowerBinId.sub(depositMinBinId);
-      for (let i = 1; i <= binCountToExpand.toNumber(); i++) {
-        const binId = this.lowerBinId.subn(i);
-        const price = getPriceOfBinByBinId(
-          binId.toNumber(),
-          binStep.toNumber()
-        );
-        const adjustedPrice = price.mul(tokenXMultiplier).div(tokenYMultiplier);
-        this.rebalancePositionBinData.unshift({
-          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)
-        });
-      }
+  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 {
-      const binCountToShrink = newMinBinId.sub(this.lowerBinId);
-      for (let i = 1; i <= binCountToShrink.toNumber(); i++) {
-        this.rebalancePositionBinData.shift();
-      }
+      maxBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
     }
-    if (newMaxBinId.gt(this.upperBinId)) {
-      const binCountToExpand = newMaxBinId.sub(this.upperBinId);
-      for (let i = 1; i <= binCountToExpand.toNumber(); i++) {
-        const binId = this.upperBinId.addn(i);
-        const price = getPriceOfBinByBinId(
-          binId.toNumber(),
-          binStep.toNumber()
-        );
-        const adjustedPrice = price.mul(tokenXMultiplier).div(tokenYMultiplier);
-        this.rebalancePositionBinData.push({
-          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)
-        });
-      }
+    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
+    );
+    return {
+      amount: amountY,
+      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 {
-      const binCountToShrink = this.upperBinId.sub(newMaxBinId);
-      for (let i = 1; i <= binCountToShrink.toNumber(); i++) {
-        this.rebalancePositionBinData.pop();
-      }
+      minBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
     }
-    this.lowerBinId = newMinBinId;
-    this.upperBinId = newMaxBinId;
+    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
+    );
+    return {
+      amount: amountX,
+      isBidSide: false
+    };
+  } else {
+    return {
+      amount: new BN15(0),
+      isBidSide: false
+    };
   }
-  _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);
-    for (const { minBinId, maxBinId, bps } of withdraws) {
-      const fromBinId = minBinId ?? activeId;
-      const toBinId = maxBinId ?? activeId;
-      const binIds = binRangeToBinIdArray(fromBinId, toBinId).filter(
-        (binId) => binId.gte(this.lowerBinId) && binId.lte(this.upperBinId)
-      );
-      for (const binId of binIds) {
-        const idx = this.rebalancePositionBinData.findIndex(
-          (b) => b.binId === binId.toNumber()
-        );
-        const binData = this.rebalancePositionBinData[idx];
-        const amountXWithdrawn = binData.amountX.mul(bps).divn(BASIS_POINT_MAX);
-        const amountYWithdrawn = binData.amountY.mul(bps).divn(BASIS_POINT_MAX);
-        liquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn.add(amountXWithdrawn);
-        liquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn.add(amountYWithdrawn);
-        binData.amountX = binData.amountX.sub(amountXWithdrawn);
-        binData.amountY = binData.amountY.sub(amountYWithdrawn);
-        if (this.shouldClaimFee) {
-          liquidityAndFeeXWithdrawn = liquidityAndFeeXWithdrawn.add(
-            binData.claimableFeeXAmount
-          );
-          liquidityAndFeeYWithdrawn = liquidityAndFeeYWithdrawn.add(
-            binData.claimableFeeYAmount
-          );
-          binData.claimableFeeXAmount = new BN14(0);
-          binData.claimableFeeYAmount = new BN14(0);
-        }
-        if (this.shouldClaimReward) {
-          for (const [idx2, amount] of binData.claimableRewardAmount.entries()) {
-            rewardsAmountClaimed[idx2] = rewardsAmountClaimed[idx2].add(amount);
-            binData.claimableRewardAmount[idx2] = new BN14(0);
-          }
-        }
-        this.rebalancePositionBinData[idx] = binData;
-      }
-    }
-    const withdrawParams = withdraws.map(
-      ({ minBinId, maxBinId, bps }) => {
-        return {
-          minBinId: minBinId ? minBinId.toNumber() : null,
-          maxBinId: maxBinId ? maxBinId.toNumber() : null,
-          bps: bps.toNumber(),
-          padding: Array(16).fill(0)
-        };
-      }
+}
+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),
+      amountY: new BN15(0)
+    };
+  }
+  const minXDeltaId = startDeltaIdAskSide;
+  const maxXDeltaId = maxDeltaId;
+  const amountXInBins = toAmountIntoBins(
+    activeId,
+    minXDeltaId,
+    maxXDeltaId,
+    deltaX,
+    new BN15(0),
+    x0,
+    new BN15(0),
+    binStep,
+    favorXInActiveBin
+  );
+  const totalAmountXInQuote = amountXInBins.reduce((acc, bin) => {
+    const price = getPriceOfBinByBinId(
+      bin.binId.toNumber(),
+      binStep.toNumber()
     );
+    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
+  );
+}
+function buildLiquidityStrategyParameters(amountX, amountY, minDeltaId, maxDeltaId, binStep, favorXInActiveId, activeId, strategyParameterBuilder) {
+  if (minDeltaId.gt(maxDeltaId)) {
     return {
-      result: {
-        liquidityAndFeeXWithdrawn,
-        liquidityAndFeeYWithdrawn,
-        rewardsAmountClaimed
-      },
-      withdrawParams
+      x0: new BN15(0),
+      y0: new BN15(0),
+      deltaX: new BN15(0),
+      deltaY: new BN15(0)
     };
   }
-  async simulateRebalance(connection, binStep, tokenXDecimal, tokenYDecimal, withdraws, deposits) {
-    if (withdraws.length == 0 && deposits.length == 0) {
-      throw "No rebalance action";
-    }
-    const activeId = new BN14(this.lbPair.activeId);
-    withdraws = validateAndSortRebalanceWithdraw(withdraws, activeId);
-    deposits = validateAndSortRebalanceDeposit(deposits);
-    const beforeWidth = getPositionWidthWithMinWidth(
-      this.lowerBinId.toNumber(),
-      this.upperBinId.toNumber()
+  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,
+      activeId
     );
-    const { withdrawParams, result: withdrawResult } = this._simulateWithdraw(withdraws);
-    const { depositParams, result: depositResult } = this._simulateDeposit(
+    return {
+      x0: new BN15(0),
+      deltaX: new BN15(0),
+      y0: base,
+      deltaY: delta
+    };
+  }
+  if (depositOnlyX) {
+    const { base, delta } = strategyParameterBuilder.findXParameters(
+      amountX,
+      minDeltaId,
+      maxDeltaId,
       binStep,
-      tokenXDecimal,
-      tokenYDecimal,
-      deposits,
-      withdrawResult
-    );
-    const afterWidth = getPositionWidthWithMinWidth(
-      this.lowerBinId.toNumber(),
-      this.upperBinId.toNumber()
+      activeId
     );
-    const widthDelta = afterWidth - beforeWidth;
-    let rentalCostLamports = new BN14(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)
-      );
-      if (widthDelta > 0) {
-        rentalCostLamports = rentalCostLamports.add(lamportChanges);
-      } else {
-        rentalCostLamports = rentalCostLamports.sub(lamportChanges);
-      }
-    }
     return {
-      amountXDeposited: depositResult.totalAmountXDeposited,
-      amountYDeposited: depositResult.totalAmountYDeposited,
-      actualAmountXDeposited: depositResult.actualTotalAmountXDeposited,
-      actualAmountYDeposited: depositResult.actualTotalAmountYDeposited,
-      actualAmountXWithdrawn: depositResult.actualLiquidityAndFeeXWithdrawn,
-      actualAmountYWithdrawn: depositResult.actualLiquidityAndFeeYWithdrawn,
-      rewardAmountsClaimed: withdrawResult.rewardsAmountClaimed,
-      withdrawParams,
-      depositParams,
-      rentalCostLamports
+      x0: base,
+      deltaX: delta,
+      y0: new BN15(0),
+      deltaY: new BN15(0)
     };
   }
-  totalAmounts() {
-    let totalAmountX = new BN14(0);
-    let totalAmountY = new BN14(0);
-    for (const binData of this.rebalancePositionBinData) {
-      totalAmountX = totalAmountX.add(binData.amountX);
-      totalAmountY = totalAmountY.add(binData.amountY);
-    }
-    return [totalAmountX, totalAmountY];
-  }
-  totalFeeAmounts() {
-    let totalFeeXAmount = new BN14(0);
-    let totalFeeYAmount = new BN14(0);
-    for (const binData of this.rebalancePositionBinData) {
-      totalFeeXAmount = totalFeeXAmount.add(binData.claimableFeeXAmount);
-      totalFeeYAmount = totalFeeYAmount.add(binData.claimableFeeYAmount);
-    }
-    return [totalFeeXAmount, totalFeeYAmount];
-  }
-  totalRewardAmounts() {
-    let totalRewardAmounts = [new BN14(0), new BN14(0)];
-    for (const binData of this.rebalancePositionBinData) {
-      totalRewardAmounts[0] = totalRewardAmounts[0].add(
-        binData.claimableRewardAmount[0]
-      );
-      totalRewardAmounts[1] = totalRewardAmounts[1].add(
-        binData.claimableRewardAmount[1]
+  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;
     }
-    return totalRewardAmounts;
   }
 };
-function getPositionWidthWithMinWidth(lowerBinId, upperBinId) {
-  const width = upperBinId - lowerBinId + 1;
-  return Math.max(width, DEFAULT_BIN_PER_POSITION.toNumber());
+async function getTokenBalance(conn, tokenAccount) {
+  const acc = await getAccount(conn, tokenAccount);
+  return acc.amount;
 }
-function validateAndSortRebalanceDeposit(deposits) {
-  const sortedDeposits = deposits.sort(
-    (a, b) => a.minDeltaId.sub(b.minDeltaId).toNumber()
-  );
-  for (const deposit of deposits) {
-    if (deposit.minDeltaId.gte(deposit.maxDeltaId)) {
-      throw "Invalid minDeltaId or maxDeltaId";
-    }
+var parseLogs = (eventParser, logs) => {
+  if (!logs.length)
+    throw new Error("No logs found");
+  for (const event of eventParser?.parseLogs(logs)) {
+    return event.data;
   }
-  for (let i = 1; i < sortedDeposits.length; i++) {
-    const prevDeposit = sortedDeposits[i - 1];
-    const currDeposit = sortedDeposits[i];
-    if (prevDeposit.maxDeltaId.gte(currDeposit.minDeltaId)) {
-      throw "Overlap deposit bin range";
-    }
+  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 sortedDeposits;
+  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;
 }
-function validateAndSortRebalanceWithdraw(withdraws, activeId) {
-  const filledWithdraws = [];
-  for (const { minBinId, maxBinId, bps } of withdraws) {
-    if (bps.toNumber() < 0 || bps.toNumber() > BASIS_POINT_MAX) {
-      throw "Invalid bps";
-    }
-    const filledMinBinId = minBinId ?? activeId;
-    const filledMaxBinId = maxBinId ?? activeId;
-    if (filledMinBinId.gt(filledMaxBinId)) {
-      throw "Invalid minBinId or maxBinId";
-    }
-    filledWithdraws.push({
-      minBinId: filledMinBinId,
-      maxBinId: filledMaxBinId,
-      bps
-    });
+var getEstimatedComputeUnitUsageWithBuffer = async (connection, instructions, feePayer, buffer) => {
+  if (!buffer) {
+    buffer = 0.1;
   }
-  filledWithdraws.sort((a, b) => {
-    return a.minBinId.sub(b.minBinId).toNumber();
-  });
-  for (let i = 1; i < filledWithdraws.length; i++) {
-    const prev = filledWithdraws[i - 1];
-    const curr = filledWithdraws[i];
-    if (curr.minBinId.lte(prev.maxBinId)) {
-      throw "Overlap withdraw bin range";
-    }
+  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 filledWithdraws;
+  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 binRangeToBinIdArray(minBinId, maxBinId) {
-  const binIdArray = [];
-  const fromBinId = minBinId.toNumber();
-  const toBinId = maxBinId.toNumber();
-  for (let binId = fromBinId; binId <= toBinId; binId++) {
-    binIdArray.push(new BN14(binId));
+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;
   }
-  return binIdArray;
+  if (slippage < 0) {
+    slippage = 0;
+  }
+  return slippage;
 }
-function getRebalanceBinArrayIndexesAndBitmapCoverage(adds, removes, activeId, pairAddress, programId) {
-  let indexMap = /* @__PURE__ */ new Map();
-  removes.forEach((value) => {
-    let minBinId = value.minBinId;
-    if (minBinId == null) {
-      minBinId = activeId;
+
+// 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
     }
-    let maxBinId = value.maxBinId;
-    if (maxBinId == null) {
-      maxBinId = activeId;
+  };
+};
+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
     }
-    let binArrayIndex = binIdToBinArrayIndex(new BN14(minBinId));
-    const upperBinId = new BN14(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));
-      }
+  };
+};
+var positionOwnerFilter = (owner) => {
+  return {
+    memcmp: {
+      bytes: owner.toBase58(),
+      offset: 8 + 32
     }
-  });
-  adds.forEach((value) => {
-    const minBinId = activeId + value.minDeltaId;
-    const maxBinId = activeId + value.maxDeltaId;
-    let binArrayIndex = binIdToBinArrayIndex(new BN14(minBinId));
-    const upperBinId = new BN14(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));
-      }
+  };
+};
+var positionLbPairFilter = (lbPair) => {
+  return {
+    memcmp: {
+      bytes: bs58.encode(lbPair.toBuffer()),
+      offset: 8
     }
-  });
-  const binArrayIndexes = Array.from(indexMap.keys()).map((idx) => new BN14(idx));
-  const requireBitmapExtension = binArrayIndexes.some(
-    (index) => isOverflowDefaultBinArrayBitmap(new BN14(index))
-  );
+  };
+};
+var positionV2Filter = () => {
   return {
-    binArrayIndexes,
-    binArrayBitmap: requireBitmapExtension ? deriveBinArrayBitmapExtension(pairAddress, programId)[0] : programId
+    memcmp: {
+      bytes: bs58.encode(Buffer.from(getAccountDiscriminator("positionV2"))),
+      offset: 0
+    }
   };
-}
+};
 
-// src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
+// src/dlmm/helpers/positions/index.ts
 import BN18 from "bn.js";
 
-// src/dlmm/helpers/rebalance/liquidity_strategy/bidAsk.ts
-import BN15 from "bn.js";
-function findMinY0(amountY, minDeltaId, maxDeltaId) {
-  const binCount = maxDeltaId.sub(minDeltaId).addn(1);
-  const totalWeight = binCount.mul(binCount.addn(1)).divn(2);
-  return amountY.div(totalWeight);
-}
-function findBaseDeltaY(amountY, minDeltaId, maxDeltaId, minY0) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.lte(new BN15(0))) {
-    return new BN15(0);
-  }
-  if (minDeltaId.eq(maxDeltaId)) {
-    return amountY;
+// 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);
   }
-  const m1 = minDeltaId.neg();
-  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));
-  const e = minY0;
-  return amountY.sub(e).div(a);
+  return {
+    liquidityShares: combinedLiquidityShares,
+    rewardInfos: combinedRewardInfos,
+    feeInfos: combinedFeeInfos
+  };
 }
-function findY0AndDeltaY(amountY, minDeltaId, maxDeltaId, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountY.isZero()) {
-    return {
-      base: new BN15(0),
-      delta: new BN15(0)
-    };
-  }
-  const minY0 = findMinY0(amountY, minDeltaId, maxDeltaId);
-  let baseDeltaY = findBaseDeltaY(amountY, minDeltaId, maxDeltaId, minY0);
-  const y0 = baseDeltaY.neg().mul(maxDeltaId).add(minY0);
-  while (true) {
-    const amountInBins = getAmountInBinsBidSide(
-      activeId,
-      minDeltaId,
-      maxDeltaId,
-      baseDeltaY,
-      y0
+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 totalAmountY = amountInBins.reduce((acc, { amountY: amountY2 }) => {
-      return acc.add(amountY2);
-    }, new BN15(0));
-    if (totalAmountY.gt(amountY)) {
-      baseDeltaY = baseDeltaY.sub(new BN15(1));
-    } else {
-      return {
-        base: y0,
-        delta: baseDeltaY
-      };
-    }
-  }
-}
-function findMinX0(amountX, minDeltaId, maxDeltaId, activeId, binStep) {
-  const minBinId = activeId.add(minDeltaId);
-  const maxBinId = activeId.add(maxDeltaId);
-  let totalWeight = new BN15(0);
-  for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
-    const binDelta = binId - minBinId.toNumber() + 1;
-    const binPrice = getQPriceFromId(new BN15(binId), binStep);
-    const weight = new BN15(binDelta).mul(binPrice);
-    totalWeight = totalWeight.add(weight);
-  }
-  return amountX.shln(SCALE_OFFSET).div(totalWeight);
-}
-function findBaseDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId, minX0) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN15(0))) {
-    return new BN15(0);
-  }
-  let b = new BN15(0);
-  let c = new BN15(0);
-  let m1 = minDeltaId;
-  let m2 = maxDeltaId;
-  console.log(m1.toNumber(), m2.toNumber());
-  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);
-    c = c.add(cDelta);
-  }
-  console.log(amountX.sub(minX0).shln(SCALE_OFFSET).div(c.sub(b)).toString());
-  return amountX.sub(minX0).shln(SCALE_OFFSET).div(c.sub(b));
-}
-function findX0AndDeltaX(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN15(0)) || amountX.isZero()) {
-    return {
-      base: new BN15(0),
-      delta: new BN15(0)
-    };
-  }
-  const minX0 = findMinX0(amountX, minDeltaId, maxDeltaId, activeId, binStep);
-  let baseDeltaX = findBaseDeltaX(
-    amountX,
-    minDeltaId,
-    maxDeltaId,
-    binStep,
-    activeId,
-    minX0
-  );
-  console.log("\u{1F680} ~ baseDeltaX:", baseDeltaX.toString());
-  const x0 = minDeltaId.neg().mul(baseDeltaX).add(minX0);
-  console.log("\u{1F680} ~ x0:", x0.toString());
-  while (true) {
-    const amountInBins = getAmountInBinsAskSide(
-      activeId,
-      binStep,
-      minDeltaId,
-      maxDeltaId,
-      baseDeltaX,
-      x0
+    const extended = decodeExtendedPosition(
+      state,
+      program,
+      account.data.subarray(8 + POSITION_MIN_SIZE)
     );
-    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
-      };
-    }
-  }
-}
-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);
-  }
-};
-
-// 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 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 combinedPositionBinData = combineBaseAndExtendedPositionBinData(
+      state,
+      extended
     );
-    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
-      };
-    }
+    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
+  } else {
+    throw new Error("Unknown position account");
   }
 }
-function findBaseX0(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-  if (minDeltaId.gt(maxDeltaId) || amountX.lte(new BN16(0))) {
-    return new BN16(0);
+var PositionV2Wrapper = class {
+  constructor(positionAddress, inner, extended, combinedPositionBinData) {
+    this.positionAddress = positionAddress;
+    this.inner = inner;
+    this.extended = extended;
+    this.combinedPositionBinData = combinedPositionBinData;
   }
-  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);
+  address() {
+    return this.positionAddress;
   }
-  return amountX.shln(SCALE_OFFSET).div(b.sub(c));
-}
-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)
-    };
+  totalClaimedRewards() {
+    return this.inner.totalClaimedRewards;
   }
-  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 BN16(0));
-    if (totalAmountX.gt(amountX)) {
-      baseX0 = baseX0.sub(new BN16(1));
-    } else {
-      return {
-        base: baseX0,
-        delta: deltaX
-      };
-    }
+  feeOwner() {
+    return this.inner.feeOwner;
   }
-}
-var CurveStrategyParameterBuilder = class {
-  findXParameters(amountX, minDeltaId, maxDeltaId, binStep, activeId) {
-    return findX0AndDeltaX2(amountX, minDeltaId, maxDeltaId, binStep, activeId);
+  lockReleasePoint() {
+    return this.inner.lockReleasePoint;
   }
-  findYParameters(amountY, minDeltaId, maxDeltaId, activeId) {
-    return findY0AndDeltaY2(amountY, minDeltaId, maxDeltaId, activeId);
+  operator() {
+    return this.inner.operator;
   }
-};
-
-// 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);
+  totalClaimedFeeYAmount() {
+    return this.inner.totalClaimedFeeYAmount;
   }
-  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);
+  totalClaimedFeeXAmount() {
+    return this.inner.totalClaimedFeeXAmount;
   }
-  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);
+  lbPair() {
+    return this.inner.lbPair;
   }
-  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));
+  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 */;
+  }
+  owner() {
+    return this.inner.owner;
+  }
+  width() {
+    return this.upperBinId().sub(this.lowerBinId()).add(new BN17(1));
   }
 };
 
-// src/dlmm/helpers/rebalance/liquidity_strategy/index.ts
-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
@@ -14160,11 +14427,11 @@ var DLMM = class {
     return positionsMap;
   }
   static getPricePerLamport(tokenXDecimal, tokenYDecimal, price) {
-    return new Decimal7(price).mul(new Decimal7(10 ** (tokenYDecimal - tokenXDecimal))).toString();
+    return new Decimal8(price).mul(new Decimal8(10 ** (tokenYDecimal - tokenXDecimal))).toString();
   }
   static getBinIdFromPrice(price, binStep, min) {
-    const binStepNum = new Decimal7(binStep).div(new Decimal7(BASIS_POINT_MAX));
-    const binId = new Decimal7(price).log().dividedBy(new Decimal7(1).add(binStepNum).log());
+    const binStepNum = new Decimal8(binStep).div(new Decimal8(BASIS_POINT_MAX));
+    const binId = new Decimal8(price).log().dividedBy(new Decimal8(1).add(binStepNum).log());
     return (min ? binId.floor() : binId.ceil()).toNumber();
   }
   /**
@@ -14776,8 +15043,8 @@ var DLMM = class {
    */
   static calculateFeeInfo(baseFactor, binStep, baseFeePowerFactor) {
     const baseFeeRate = new BN21(baseFactor).mul(new BN21(binStep)).mul(new BN21(10)).mul(new BN21(10).pow(new BN21(baseFeePowerFactor ?? 0)));
-    const baseFeeRatePercentage = new Decimal7(baseFeeRate.toString()).mul(new Decimal7(100)).div(new Decimal7(FEE_PRECISION.toString()));
-    const maxFeeRatePercentage = new Decimal7(MAX_FEE_RATE.toString()).mul(new Decimal7(100)).div(new Decimal7(FEE_PRECISION.toString()));
+    const baseFeeRatePercentage = new Decimal8(baseFeeRate.toString()).mul(new Decimal8(100)).div(new Decimal8(FEE_PRECISION.toString()));
+    const maxFeeRatePercentage = new Decimal8(MAX_FEE_RATE.toString()).mul(new Decimal8(100)).div(new Decimal8(FEE_PRECISION.toString()));
     return {
       baseFeeRatePercentage,
       maxFeeRatePercentage
@@ -14795,7 +15062,7 @@ var DLMM = class {
       this.lbPair.binStep,
       this.lbPair.parameters.baseFeePowerFactor
     );
-    const protocolFeePercentage = new Decimal7(protocolShare.toString()).mul(new Decimal7(100)).div(new Decimal7(BASIS_POINT_MAX));
+    const protocolFeePercentage = new Decimal8(protocolShare.toString()).mul(new Decimal8(100)).div(new Decimal8(BASIS_POINT_MAX));
     return {
       baseFeeRatePercentage,
       maxFeeRatePercentage,
@@ -14827,7 +15094,7 @@ var DLMM = class {
       sParameters3,
       vParameterClone
     );
-    return new Decimal7(totalFee.toString()).div(new Decimal7(FEE_PRECISION.toString())).mul(100);
+    return new Decimal8(totalFee.toString()).div(new Decimal8(FEE_PRECISION.toString())).mul(100);
   }
   /**
    * The function `getEmissionRate` returns the emission rates for two rewards.
@@ -14840,8 +15107,8 @@ var DLMM = class {
       ({ rewardRate, rewardDurationEnd }) => now > rewardDurationEnd.toNumber() ? void 0 : rewardRate
     );
     return {
-      rewardOne: rewardOneEmissionRate ? new Decimal7(rewardOneEmissionRate.toString()).div(PRECISION) : void 0,
-      rewardTwo: rewardTwoEmissionRate ? new Decimal7(rewardTwoEmissionRate.toString()).div(PRECISION) : void 0
+      rewardOne: rewardOneEmissionRate ? new Decimal8(rewardOneEmissionRate.toString()).div(PRECISION) : void 0,
+      rewardTwo: rewardTwoEmissionRate ? new Decimal8(rewardTwoEmissionRate.toString()).div(PRECISION) : void 0
     };
   }
   /**
@@ -14934,8 +15201,8 @@ var DLMM = class {
    * @returns {string} real price of bin
    */
   fromPricePerLamport(pricePerLamport) {
-    return new Decimal7(pricePerLamport).div(
-      new Decimal7(
+    return new Decimal8(pricePerLamport).div(
+      new Decimal8(
         10 ** (this.tokenY.mint.decimals - this.tokenX.mint.decimals)
       )
     ).toString();
@@ -15093,12 +15360,12 @@ var DLMM = class {
     const lowerBinArrayIndex = binIdToBinArrayIndex(currentMinBinId);
     const upperBinArrayIndex = binIdToBinArrayIndex(currentMaxBinId);
     const binArraysCount = (await this.binArraysToBeCreate(lowerBinArrayIndex, upperBinArrayIndex)).length;
-    const binArrayCost = new Decimal7(binArraysCount).mul(
-      new Decimal7(BIN_ARRAY_FEE)
+    const binArrayCost = new Decimal8(binArraysCount).mul(
+      new Decimal8(BIN_ARRAY_FEE)
     );
     return {
-      positionExtendCost: new Decimal7(positionExtendCost).div(
-        new Decimal7(LAMPORTS_PER_SOL2)
+      positionExtendCost: new Decimal8(positionExtendCost).div(
+        new Decimal8(LAMPORTS_PER_SOL2)
       ),
       binArrayCost
     };
@@ -16367,7 +16634,7 @@ var DLMM = class {
       activeId.toNumber(),
       this.lbPair.binStep
     );
-    const priceImpact = startPrice.sub(endPrice).abs().div(startPrice).mul(new Decimal7(100));
+    const priceImpact = startPrice.sub(endPrice).abs().div(startPrice).mul(new Decimal8(100));
     actualInAmount = calculateTransferFeeIncludedAmount(
       actualInAmount.add(feeAmount),
       inMint,
@@ -16554,7 +16821,7 @@ var DLMM = class {
       ),
       swapForY
     );
-    const priceImpact = new Decimal7(totalOutAmount.toString()).sub(new Decimal7(outAmountWithoutSlippage.toString())).div(new Decimal7(outAmountWithoutSlippage.toString())).mul(new Decimal7(100)).abs();
+    const priceImpact = new Decimal8(totalOutAmount.toString()).sub(new Decimal8(outAmountWithoutSlippage.toString())).div(new Decimal8(outAmountWithoutSlippage.toString())).mul(new Decimal8(100)).abs();
     const endPrice = getPriceOfBinByBinId(
       lastFilledActiveBinId.toNumber(),
       this.lbPair.binStep
@@ -17163,11 +17430,11 @@ var DLMM = class {
     let totalBinArraysCount = new BN21(0);
     let totalBinArraysLamports = new BN21(0);
     let binArrayBitmapLamports = new BN21(0);
-    const toLamportMultiplier = new Decimal7(
+    const toLamportMultiplier = new Decimal8(
       10 ** (this.tokenY.mint.decimals - this.tokenX.mint.decimals)
     );
-    const minPricePerLamport = new Decimal7(minPrice).mul(toLamportMultiplier);
-    const maxPricePerLamport = new Decimal7(maxPrice).mul(toLamportMultiplier);
+    const minPricePerLamport = new Decimal8(minPrice).mul(toLamportMultiplier);
+    const maxPricePerLamport = new Decimal8(maxPrice).mul(toLamportMultiplier);
     const minBinId = new BN21(
       DLMM.getBinIdFromPrice(minPricePerLamport, this.lbPair.binStep, false)
     );
@@ -18158,7 +18425,6 @@ var DLMM = class {
       shouldClaimReward: true,
       pairAddress: this.pubkey
     });
-    console.log("\u{1F680} ~ DLMM ~ rebalancePosition:", rebalancePosition);
     const rebalanceStrategyBuilder = new BalancedStrategyBuilder(
       new BN21(rebalancePosition.lbPair.activeId),
       new BN21(rebalancePosition.lbPair.binStep),
@@ -18184,10 +18450,65 @@ var DLMM = class {
       withdraws,
       deposits
     );
-    console.log("\u{1F680} ~ DLMM ~ simulationResult:", simulationResult);
+    const binArrayQuoteResult = await this.quoteBinArrayAccountsRentalCost(
+      simulationResult.depositParams,
+      simulationResult.withdrawParams,
+      new BN21(rebalancePosition.lbPair.activeId)
+    );
     return {
       rebalancePosition,
-      simulationResult
+      simulationResult,
+      ...binArrayQuoteResult
+    };
+  }
+  async quoteBinArrayAccountsRentalCost(deposits, withdraws, activeId) {
+    const { binArrayBitmap, binArrayIndexes } = getRebalanceBinArrayIndexesAndBitmapCoverage(
+      deposits,
+      withdraws,
+      activeId.toNumber(),
+      this.pubkey,
+      this.program.programId
+    );
+    const binArrayPublicKeys = binArrayIndexes.map((index) => {
+      const [binArrayPubkey] = deriveBinArray(
+        this.pubkey,
+        index,
+        this.program.programId
+      );
+      return binArrayPubkey;
+    });
+    const accountPublicKeys = [...binArrayPublicKeys];
+    if (!binArrayBitmap.equals(PublicKey10.default)) {
+      accountPublicKeys.push(binArrayBitmap);
+    }
+    const accounts = await chunkedGetMultipleAccountInfos(
+      this.program.provider.connection,
+      binArrayPublicKeys
+    );
+    const binArrayAccounts = accounts.splice(0, binArrayPublicKeys.length);
+    let binArrayCount = 0;
+    let bitmapExtensionCost = 0;
+    const binArraySet = /* @__PURE__ */ new Set();
+    for (let i = 0; i < binArrayAccounts.length; i++) {
+      const binArrayAccount = binArrayAccounts[i];
+      const binArrayPubkey = binArrayPublicKeys[i];
+      if (!binArrayAccount) {
+        binArrayCount++;
+      } else {
+        binArraySet.add(binArrayPubkey.toBase58());
+      }
+    }
+    if (!binArrayBitmap.equals(PublicKey10.default)) {
+      const bitmapAccount = accounts.pop();
+      if (!bitmapAccount) {
+        bitmapExtensionCost = BIN_ARRAY_BITMAP_FEE;
+      }
+    }
+    return {
+      binArrayCost: binArrayCount * BIN_ARRAY_FEE,
+      binArrayCount,
+      binArrayExistence: binArraySet,
+      bitmapExtensionCost
     };
   }
   /**
@@ -18217,9 +18538,15 @@ var DLMM = class {
       withdraws,
       deposits
     );
+    const binArrayQuoteResult = await this.quoteBinArrayAccountsRentalCost(
+      simulationResult.depositParams,
+      simulationResult.withdrawParams,
+      new BN21(rebalancePosition.lbPair.activeId)
+    );
     return {
       rebalancePosition,
-      simulationResult
+      simulationResult,
+      ...binArrayQuoteResult
     };
   }
   /**
@@ -18297,12 +18624,10 @@ var DLMM = class {
         chunk,
         activeId
       );
-      console.log("\u{1F680} ~ DLMM ~ chunkedDepositParams:", chunkedDepositParams);
       const chunkedWithdrawParams = splitWithdrawParamsForChunk(
         withdrawParams,
         chunk
       );
-      console.log("\u{1F680} ~ DLMM ~ chunkedWithdrawParams:", chunkedWithdrawParams);
       if (chunkedDepositParams.length === 0 && chunkedWithdrawParams.length === 0)
         continue;
       const { slices, accounts: transferHookAccounts } = this.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
@@ -18668,8 +18993,8 @@ var DLMM = class {
     if (!bins.length)
       return null;
     const positionData = [];
-    let totalXAmount = new Decimal7(0);
-    let totalYAmount = new Decimal7(0);
+    let totalXAmount = new Decimal8(0);
+    let totalYAmount = new Decimal8(0);
     const ZERO = new BN21(0);
     let feeX = ZERO;
     let feeY = ZERO;
@@ -18680,8 +19005,8 @@ var DLMM = class {
       const posBinRewardInfo = positionRewardInfos[idx];
       const positionXAmount = binSupply.eq(ZERO) ? ZERO : posShare.mul(bin.xAmount).div(binSupply);
       const positionYAmount = binSupply.eq(ZERO) ? ZERO : posShare.mul(bin.yAmount).div(binSupply);
-      totalXAmount = totalXAmount.add(new Decimal7(positionXAmount.toString()));
-      totalYAmount = totalYAmount.add(new Decimal7(positionYAmount.toString()));
+      totalXAmount = totalXAmount.add(new Decimal8(positionXAmount.toString()));
+      totalYAmount = totalYAmount.add(new Decimal8(positionYAmount.toString()));
       const feeInfo = feeInfos[idx];
       const newFeeX = mulShr(
         posShares[idx].shrn(SCALE_OFFSET),
@@ -18845,7 +19170,7 @@ var DLMM = class {
               rewardPerTokenStored: [ZERO, ZERO],
               price: pricePerLamport,
               version: 2,
-              pricePerToken: new Decimal7(pricePerLamport).mul(new Decimal7(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString()
+              pricePerToken: new Decimal8(pricePerLamport).mul(new Decimal8(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString()
             });
           } else {
             const bin = binArray.bins[i];
@@ -18859,7 +19184,7 @@ var DLMM = class {
               rewardPerTokenStored: bin.rewardPerTokenStored,
               price: pricePerLamport,
               version: binArray.version,
-              pricePerToken: new Decimal7(pricePerLamport).mul(new Decimal7(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString()
+              pricePerToken: new Decimal8(pricePerLamport).mul(new Decimal8(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString()
             });
           }
         }
@@ -19218,6 +19543,7 @@ export {
   PairStatus,
   PairType,
   PositionVersion,
+  RebalancePosition,
   ResizeSide,
   SCALE,
   SCALE_OFFSET,
@@ -19232,6 +19558,7 @@ export {
   autoFillYByStrategy,
   autoFillYByWeight,
   binIdToBinArrayIndex,
+  buildLiquidityStrategyParameters,
   calculateBidAskDistribution,
   calculateNormalDistribution,
   calculateSpotDistribution,
@@ -19268,6 +19595,9 @@ export {
   fromWeightDistributionToAmount,
   fromWeightDistributionToAmountOneSide,
   getAccountDiscriminator,
+  getAmountInBinsAskSide,
+  getAmountInBinsBidSide,
+  getAutoFillAmountByRebalancedPosition,
   getBaseFee,
   getBinArrayLowerUpperBinId,
   getBinArraysRequiredByPositionRange,
@@ -19275,9 +19605,11 @@ export {
   getBinIdIndexInBinArray,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
+  getLiquidityStrategyParameterBuilder,
   getOrCreateATAInstruction,
   getOutAmount,
   getPriceOfBinByBinId,
+  getRebalanceBinArrayIndexesAndBitmapCoverage,
   getTokenBalance,
   getTokenDecimals,
   getTokenProgramId,
@@ -19288,11 +19620,14 @@ export {
   isOverflowDefaultBinArrayBitmap,
   parseLogs,
   range,
+  suggestBalancedXParametersFromY,
+  suggestBalancedYParametersFromX,
   swapExactInQuoteAtBin,
   swapExactOutQuoteAtBin,
   toAmountAskSide,
   toAmountBidSide,
   toAmountBothSide,
+  toAmountIntoBins,
   toAmountsBothSideByStrategy,
   toStrategyParameters,
   toWeightDistribution,