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

package/dist/index.js

@@ -9219,7 +9219,7 @@ var ILM_BASE = new (0, _web3js.PublicKey)(
 var MAX_EXTRA_BIN_ARRAYS = 3;
 var U64_MAX = new (0, _anchor.BN)("18446744073709551615");
 var MAX_BINS_PER_POSITION = new (0, _anchor.BN)(
-  _nullishCoalesce(_optionalChain([CONSTANTS, 'access', _26 => _26.find, 'call', _27 => _27(([k, v]) => v.name == "MAX_BINS_PER_POSITION"), 'optionalAccess', _28 => _28[1], 'access', _29 => _29.value]), () => ( 0))
+  _nullishCoalesce(_optionalChain([CONSTANTS, 'access', _26 => _26.find, 'call', _27 => _27(([k, v]) => v.name == "POSITION_MAX_LENGTH"), 'optionalAccess', _28 => _28[1], 'access', _29 => _29.value]), () => ( 0))
 );
 
 // src/dlmm/error.ts
@@ -9285,6 +9285,116 @@ var DlmmSdkError = class extends Error {
 
 
 
+// src/dlmm/types/index.ts
+
+
+
+
+
+
+
+var _borsh = require('@coral-xyz/borsh');
+var PositionVersion = /* @__PURE__ */ ((PositionVersion3) => {
+  PositionVersion3[PositionVersion3["V1"] = 0] = "V1";
+  PositionVersion3[PositionVersion3["V2"] = 1] = "V2";
+  return PositionVersion3;
+})(PositionVersion || {});
+var PairType = /* @__PURE__ */ ((PairType2) => {
+  PairType2[PairType2["Permissionless"] = 0] = "Permissionless";
+  PairType2[PairType2["Permissioned"] = 1] = "Permissioned";
+  return PairType2;
+})(PairType || {});
+var Strategy = {
+  SpotBalanced: { spotBalanced: {} },
+  CurveBalanced: { curveBalanced: {} },
+  BidAskBalanced: { bidAskBalanced: {} },
+  SpotImBalanced: { spotImBalanced: {} },
+  CurveImBalanced: { curveImBalanced: {} },
+  BidAskImBalanced: { bidAskImBalanced: {} }
+};
+var StrategyType = /* @__PURE__ */ ((StrategyType3) => {
+  StrategyType3[StrategyType3["Spot"] = 0] = "Spot";
+  StrategyType3[StrategyType3["Curve"] = 1] = "Curve";
+  StrategyType3[StrategyType3["BidAsk"] = 2] = "BidAsk";
+  return StrategyType3;
+})(StrategyType || {});
+var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
+  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
+  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
+  return ActivationType2;
+})(ActivationType || {});
+var POSITION_MIN_SIZE = 8112;
+var POSITION_BIN_DATA_SIZE = 112;
+var BinLiquidity;
+((BinLiquidity3) => {
+  function fromBin(bin, binId, binStep, baseTokenDecimal, quoteTokenDecimal, version) {
+    const pricePerLamport = getPriceOfBinByBinId(binId, binStep).toString();
+    return {
+      binId,
+      xAmount: bin.amountX,
+      yAmount: bin.amountY,
+      supply: bin.liquiditySupply,
+      price: pricePerLamport,
+      version,
+      pricePerToken: new (0, _decimaljs2.default)(pricePerLamport).mul(new (0, _decimaljs2.default)(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString(),
+      feeAmountXPerTokenStored: bin.feeAmountXPerTokenStored,
+      feeAmountYPerTokenStored: bin.feeAmountYPerTokenStored,
+      rewardPerTokenStored: bin.rewardPerTokenStored
+    };
+  }
+  BinLiquidity3.fromBin = fromBin;
+  function empty(binId, binStep, baseTokenDecimal, quoteTokenDecimal, version) {
+    const pricePerLamport = getPriceOfBinByBinId(binId, binStep).toString();
+    return {
+      binId,
+      xAmount: new (0, _anchor.BN)(0),
+      yAmount: new (0, _anchor.BN)(0),
+      supply: new (0, _anchor.BN)(0),
+      price: pricePerLamport,
+      version,
+      pricePerToken: new (0, _decimaljs2.default)(pricePerLamport).mul(new (0, _decimaljs2.default)(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString(),
+      feeAmountXPerTokenStored: new (0, _anchor.BN)(0),
+      feeAmountYPerTokenStored: new (0, _anchor.BN)(0),
+      rewardPerTokenStored: [new (0, _anchor.BN)(0), new (0, _anchor.BN)(0)]
+    };
+  }
+  BinLiquidity3.empty = empty;
+})(BinLiquidity || (BinLiquidity = exports.BinLiquidity = {}));
+var BitmapType = /* @__PURE__ */ ((BitmapType2) => {
+  BitmapType2[BitmapType2["U1024"] = 0] = "U1024";
+  BitmapType2[BitmapType2["U512"] = 1] = "U512";
+  return BitmapType2;
+})(BitmapType || {});
+var ClockLayout = _borsh.struct.call(void 0, [
+  _borsh.u64.call(void 0, "slot"),
+  _borsh.i64.call(void 0, "epochStartTimestamp"),
+  _borsh.u64.call(void 0, "epoch"),
+  _borsh.u64.call(void 0, "leaderScheduleEpoch"),
+  _borsh.i64.call(void 0, "unixTimestamp")
+]);
+var PairStatus = /* @__PURE__ */ ((PairStatus2) => {
+  PairStatus2[PairStatus2["Enabled"] = 0] = "Enabled";
+  PairStatus2[PairStatus2["Disabled"] = 1] = "Disabled";
+  return PairStatus2;
+})(PairStatus || {});
+var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2[ActionType2["Liquidity"] = 0] = "Liquidity";
+  ActionType2[ActionType2["Reward"] = 1] = "Reward";
+  return ActionType2;
+})(ActionType || {});
+var ResizeSide = /* @__PURE__ */ ((ResizeSide2) => {
+  ResizeSide2[ResizeSide2["Lower"] = 0] = "Lower";
+  ResizeSide2[ResizeSide2["Upper"] = 1] = "Upper";
+  return ResizeSide2;
+})(ResizeSide || {});
+var MEMO_PROGRAM_ID = new (0, _web3js.PublicKey)(
+  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
+);
+
+// src/dlmm/helpers/binArray.ts
+
+
+
 // src/dlmm/helpers/math.ts
 
 
@@ -10479,169 +10589,7 @@ function generateBinAmount(amount, binStep, binId, tokenXDecimal, tokenYDecimal,
   return new (0, _anchor.BN)(c1.sub(c0).floor().toString());
 }
 
-// src/dlmm/helpers/computeUnit.ts
-
-
-
-
-
-
-
-// src/dlmm/types/index.ts
-
-
-
-
-
-
-
-var _borsh = require('@coral-xyz/borsh');
-var PositionVersion = /* @__PURE__ */ ((PositionVersion3) => {
-  PositionVersion3[PositionVersion3["V1"] = 0] = "V1";
-  PositionVersion3[PositionVersion3["V2"] = 1] = "V2";
-  return PositionVersion3;
-})(PositionVersion || {});
-var PairType = /* @__PURE__ */ ((PairType2) => {
-  PairType2[PairType2["Permissionless"] = 0] = "Permissionless";
-  PairType2[PairType2["Permissioned"] = 1] = "Permissioned";
-  return PairType2;
-})(PairType || {});
-var Strategy = {
-  SpotBalanced: { spotBalanced: {} },
-  CurveBalanced: { curveBalanced: {} },
-  BidAskBalanced: { bidAskBalanced: {} },
-  SpotImBalanced: { spotImBalanced: {} },
-  CurveImBalanced: { curveImBalanced: {} },
-  BidAskImBalanced: { bidAskImBalanced: {} }
-};
-var StrategyType = /* @__PURE__ */ ((StrategyType3) => {
-  StrategyType3[StrategyType3["Spot"] = 0] = "Spot";
-  StrategyType3[StrategyType3["Curve"] = 1] = "Curve";
-  StrategyType3[StrategyType3["BidAsk"] = 2] = "BidAsk";
-  return StrategyType3;
-})(StrategyType || {});
-var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
-  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
-  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
-  return ActivationType2;
-})(ActivationType || {});
-var POSITION_MIN_SIZE = 8112;
-var POSITION_BIN_DATA_SIZE = 112;
-var BinLiquidity;
-((BinLiquidity3) => {
-  function fromBin(bin, binId, binStep, baseTokenDecimal, quoteTokenDecimal, version) {
-    const pricePerLamport = getPriceOfBinByBinId(binId, binStep).toString();
-    return {
-      binId,
-      xAmount: bin.amountX,
-      yAmount: bin.amountY,
-      supply: bin.liquiditySupply,
-      price: pricePerLamport,
-      version,
-      pricePerToken: new (0, _decimaljs2.default)(pricePerLamport).mul(new (0, _decimaljs2.default)(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString(),
-      feeAmountXPerTokenStored: bin.feeAmountXPerTokenStored,
-      feeAmountYPerTokenStored: bin.feeAmountYPerTokenStored,
-      rewardPerTokenStored: bin.rewardPerTokenStored
-    };
-  }
-  BinLiquidity3.fromBin = fromBin;
-  function empty(binId, binStep, baseTokenDecimal, quoteTokenDecimal, version) {
-    const pricePerLamport = getPriceOfBinByBinId(binId, binStep).toString();
-    return {
-      binId,
-      xAmount: new (0, _anchor.BN)(0),
-      yAmount: new (0, _anchor.BN)(0),
-      supply: new (0, _anchor.BN)(0),
-      price: pricePerLamport,
-      version,
-      pricePerToken: new (0, _decimaljs2.default)(pricePerLamport).mul(new (0, _decimaljs2.default)(10 ** (baseTokenDecimal - quoteTokenDecimal))).toString(),
-      feeAmountXPerTokenStored: new (0, _anchor.BN)(0),
-      feeAmountYPerTokenStored: new (0, _anchor.BN)(0),
-      rewardPerTokenStored: [new (0, _anchor.BN)(0), new (0, _anchor.BN)(0)]
-    };
-  }
-  BinLiquidity3.empty = empty;
-})(BinLiquidity || (BinLiquidity = exports.BinLiquidity = {}));
-var BitmapType = /* @__PURE__ */ ((BitmapType2) => {
-  BitmapType2[BitmapType2["U1024"] = 0] = "U1024";
-  BitmapType2[BitmapType2["U512"] = 1] = "U512";
-  return BitmapType2;
-})(BitmapType || {});
-var ClockLayout = _borsh.struct.call(void 0, [
-  _borsh.u64.call(void 0, "slot"),
-  _borsh.i64.call(void 0, "epochStartTimestamp"),
-  _borsh.u64.call(void 0, "epoch"),
-  _borsh.u64.call(void 0, "leaderScheduleEpoch"),
-  _borsh.i64.call(void 0, "unixTimestamp")
-]);
-var PairStatus = /* @__PURE__ */ ((PairStatus2) => {
-  PairStatus2[PairStatus2["Enabled"] = 0] = "Enabled";
-  PairStatus2[PairStatus2["Disabled"] = 1] = "Disabled";
-  return PairStatus2;
-})(PairStatus || {});
-var ActionType = /* @__PURE__ */ ((ActionType2) => {
-  ActionType2[ActionType2["Liquidity"] = 0] = "Liquidity";
-  ActionType2[ActionType2["Reward"] = 1] = "Reward";
-  return ActionType2;
-})(ActionType || {});
-var ResizeSide = /* @__PURE__ */ ((ResizeSide2) => {
-  ResizeSide2[ResizeSide2["Lower"] = 0] = "Lower";
-  ResizeSide2[ResizeSide2["Upper"] = 1] = "Upper";
-  return ResizeSide2;
-})(ResizeSide || {});
-var MEMO_PROGRAM_ID = new (0, _web3js.PublicKey)(
-  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
-);
-
-// src/dlmm/helpers/computeUnit.ts
-var DEFAULT_ADD_LIQUIDITY_CU = 1e6;
-var DEFAULT_EXTEND_POSITION_HIGH_CU = 1e6;
-var DEFAULT_EXTEND_POSITION_LOW_CU = 3e4;
-var DEFAULT_INIT_POSITION_CU = 3e4;
-var DEFAULT_INIT_BIN_ARRAY_CU = 35e4;
-var MIN_CU_BUFFER = 5e4;
-var MAX_CU_BUFFER = 2e5;
-var getDefaultExtendPositionCU = (side) => {
-  switch (side) {
-    case 0 /* Lower */:
-      return DEFAULT_EXTEND_POSITION_HIGH_CU;
-    case 1 /* Upper */:
-      return DEFAULT_EXTEND_POSITION_LOW_CU;
-  }
-};
-var getSimulationComputeUnits = async (connection, instructions, payer, lookupTables, commitment = "confirmed") => {
-  const testInstructions = [
-    // Set an arbitrarily high number in simulation
-    // so we can be sure the transaction will succeed
-    // and get the real compute units used
-    _web3js.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
-    ...instructions
-  ];
-  const testTransaction = new (0, _web3js.VersionedTransaction)(
-    new (0, _web3js.TransactionMessage)({
-      instructions: testInstructions,
-      payerKey: payer,
-      // RecentBlockhash can by any public key during simulation
-      // since 'replaceRecentBlockhash' is set to 'true' below
-      recentBlockhash: _web3js.PublicKey.default.toString()
-    }).compileToV0Message(lookupTables)
-  );
-  const rpcResponse = await connection.simulateTransaction(testTransaction, {
-    replaceRecentBlockhash: true,
-    sigVerify: false,
-    commitment
-  });
-  if (_optionalChain([rpcResponse, 'optionalAccess', _33 => _33.value, 'optionalAccess', _34 => _34.err])) {
-    const logs = _optionalChain([rpcResponse, 'access', _35 => _35.value, 'access', _36 => _36.logs, 'optionalAccess', _37 => _37.join, 'call', _38 => _38("\n  \u2022 ")]) || "No logs available";
-    throw new Error(
-      `Transaction simulation failed:
-  \u2022${logs}` + JSON.stringify(_optionalChain([rpcResponse, 'optionalAccess', _39 => _39.value, 'optionalAccess', _40 => _40.err]))
-    );
-  }
-  return rpcResponse.value.unitsConsumed || null;
-};
-
-// src/dlmm/helpers/derive.ts
+// src/dlmm/helpers/derive.ts
 
 function sortTokenMints(tokenX, tokenY) {
   const [minKey, maxKey] = tokenX.toBuffer().compare(tokenY.toBuffer()) == 1 ? [tokenY, tokenX] : [tokenX, tokenY];
@@ -10788,10 +10736,15 @@ function deriveRewardVault(lbPair, rewardIndex, programId) {
     programId
   );
 }
+function derivePlaceHolderAccountMeta(programId) {
+  return {
+    pubkey: programId,
+    isWritable: false,
+    isSigner: false
+  };
+}
 
 // src/dlmm/helpers/binArray.ts
-
-
 function internalBitmapRange() {
   const lowerBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.neg();
   const upperBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.sub(new (0, _anchor.BN)(1));
@@ -11100,784 +11053,514 @@ function updateBinArray(activeId, clock, allRewardInfos, binArray) {
   return binArrayClone;
 }
 
-// src/dlmm/helpers/fee.ts
+// src/dlmm/helpers/computeUnit.ts
 
-function getBaseFee(binStep, sParameter) {
-  return new (0, _anchor.BN)(sParameter.baseFactor).mul(new (0, _anchor.BN)(binStep)).mul(new (0, _anchor.BN)(10)).mul(new (0, _anchor.BN)(10).pow(new (0, _anchor.BN)(sParameter.baseFeePowerFactor)));
-}
-function getVariableFee(binStep, sParameter, vParameter) {
-  if (sParameter.variableFeeControl > 0) {
-    const square_vfa_bin = new (0, _anchor.BN)(vParameter.volatilityAccumulator).mul(new (0, _anchor.BN)(binStep)).pow(new (0, _anchor.BN)(2));
-    const v_fee = new (0, _anchor.BN)(sParameter.variableFeeControl).mul(square_vfa_bin);
-    return v_fee.add(new (0, _anchor.BN)(99999999999)).div(new (0, _anchor.BN)(1e11));
+
+
+
+
+
+var DEFAULT_ADD_LIQUIDITY_CU = 1e6;
+var DEFAULT_EXTEND_POSITION_HIGH_CU = 1e6;
+var DEFAULT_EXTEND_POSITION_LOW_CU = 3e4;
+var DEFAULT_INIT_POSITION_CU = 3e4;
+var DEFAULT_INIT_BIN_ARRAY_CU = 35e4;
+var MIN_CU_BUFFER = 5e4;
+var MAX_CU_BUFFER = 2e5;
+var MAX_CU = 14e5;
+var getDefaultExtendPositionCU = (side) => {
+  switch (side) {
+    case 0 /* Lower */:
+      return DEFAULT_EXTEND_POSITION_HIGH_CU;
+    case 1 /* Upper */:
+      return DEFAULT_EXTEND_POSITION_LOW_CU;
   }
-  return new (0, _anchor.BN)(0);
-}
-function getTotalFee(binStep, sParameter, vParameter) {
-  const totalFee = getBaseFee(binStep, sParameter).add(
-    getVariableFee(binStep, sParameter, vParameter)
+};
+var getSimulationComputeUnits = async (connection, instructions, payer, lookupTables, commitment = "confirmed") => {
+  const testInstructions = [
+    // Set an arbitrarily high number in simulation
+    // so we can be sure the transaction will succeed
+    // and get the real compute units used
+    _web3js.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
+    ...instructions
+  ];
+  const testTransaction = new (0, _web3js.VersionedTransaction)(
+    new (0, _web3js.TransactionMessage)({
+      instructions: testInstructions,
+      payerKey: payer,
+      // RecentBlockhash can by any public key during simulation
+      // since 'replaceRecentBlockhash' is set to 'true' below
+      recentBlockhash: _web3js.PublicKey.default.toString()
+    }).compileToV0Message(lookupTables)
   );
-  return totalFee.gt(MAX_FEE_RATE) ? MAX_FEE_RATE : totalFee;
-}
-function computeFee(binStep, sParameter, vParameter, inAmount) {
-  const totalFee = getTotalFee(binStep, sParameter, vParameter);
-  const denominator = FEE_PRECISION.sub(totalFee);
-  return inAmount.mul(totalFee).add(denominator).sub(new (0, _anchor.BN)(1)).div(denominator);
-}
-function computeFeeFromAmount(binStep, sParameter, vParameter, inAmountWithFees) {
-  const totalFee = getTotalFee(binStep, sParameter, vParameter);
-  return inAmountWithFees.mul(totalFee).add(FEE_PRECISION.sub(new (0, _anchor.BN)(1))).div(FEE_PRECISION);
-}
-function computeProtocolFee(feeAmount, sParameter) {
-  return feeAmount.mul(new (0, _anchor.BN)(sParameter.protocolShare)).div(new (0, _anchor.BN)(BASIS_POINT_MAX));
-}
-function swapExactOutQuoteAtBin(bin, binStep, sParameter, vParameter, outAmount, swapForY) {
-  if (swapForY && bin.amountY.isZero()) {
-    return {
-      amountIn: new (0, _anchor.BN)(0),
-      amountOut: new (0, _anchor.BN)(0),
-      fee: new (0, _anchor.BN)(0),
-      protocolFee: new (0, _anchor.BN)(0)
-    };
-  }
-  if (!swapForY && bin.amountX.isZero()) {
-    return {
-      amountIn: new (0, _anchor.BN)(0),
-      amountOut: new (0, _anchor.BN)(0),
-      fee: new (0, _anchor.BN)(0),
-      protocolFee: new (0, _anchor.BN)(0)
-    };
+  const rpcResponse = await connection.simulateTransaction(testTransaction, {
+    replaceRecentBlockhash: true,
+    sigVerify: false,
+    commitment
+  });
+  if (_optionalChain([rpcResponse, 'optionalAccess', _33 => _33.value, 'optionalAccess', _34 => _34.err])) {
+    const logs = _optionalChain([rpcResponse, 'access', _35 => _35.value, 'access', _36 => _36.logs, 'optionalAccess', _37 => _37.join, 'call', _38 => _38("\n  \u2022 ")]) || "No logs available";
+    throw new Error(
+      `Transaction simulation failed:
+  \u2022${logs}` + JSON.stringify(_optionalChain([rpcResponse, 'optionalAccess', _39 => _39.value, 'optionalAccess', _40 => _40.err]))
+    );
   }
-  let maxAmountOut;
-  let maxAmountIn;
-  if (swapForY) {
-    maxAmountOut = bin.amountY;
-    maxAmountIn = shlDiv(bin.amountY, bin.price, SCALE_OFFSET, 0 /* Up */);
-  } else {
-    maxAmountOut = bin.amountX;
-    maxAmountIn = mulShr(bin.amountX, bin.price, SCALE_OFFSET, 0 /* Up */);
+  return rpcResponse.value.unitsConsumed || null;
+};
+
+// src/dlmm/helpers/positions/index.ts
+
+
+// src/dlmm/helpers/positions/wrapper.ts
+
+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);
   }
-  if (outAmount.gte(maxAmountOut)) {
-    const maxFee = computeFee(binStep, sParameter, vParameter, maxAmountIn);
-    const protocolFee = computeProtocolFee(maxFee, sParameter);
-    return {
-      amountIn: maxAmountIn,
-      amountOut: maxAmountOut,
-      fee: maxFee,
-      protocolFee
-    };
+  return {
+    liquidityShares: combinedLiquidityShares,
+    rewardInfos: combinedRewardInfos,
+    feeInfos: combinedFeeInfos
+  };
+}
+function wrapPosition(program, key, account) {
+  const disc = account.data.subarray(0, 8);
+  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
+    const state = decodeAccount(
+      program,
+      "positionV2",
+      account.data
+    );
+    const extended = decodeExtendedPosition(
+      state,
+      program,
+      account.data.subarray(8 + POSITION_MIN_SIZE)
+    );
+    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
+      state,
+      extended
+    );
+    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
   } else {
-    const amountIn = getAmountIn(outAmount, bin.price, swapForY);
-    const fee = computeFee(binStep, sParameter, vParameter, amountIn);
-    const protocolFee = computeProtocolFee(fee, sParameter);
-    return {
-      amountIn,
-      amountOut: outAmount,
-      fee,
-      protocolFee
-    };
+    throw new Error("Unknown position account");
   }
 }
-function swapExactInQuoteAtBin(bin, binStep, sParameter, vParameter, inAmount, swapForY) {
-  if (swapForY && bin.amountY.isZero()) {
-    return {
-      amountIn: new (0, _anchor.BN)(0),
-      amountOut: new (0, _anchor.BN)(0),
-      fee: new (0, _anchor.BN)(0),
-      protocolFee: new (0, _anchor.BN)(0)
-    };
+var PositionV2Wrapper = class {
+  constructor(positionAddress, inner, extended, combinedPositionBinData) {
+    this.positionAddress = positionAddress;
+    this.inner = inner;
+    this.extended = extended;
+    this.combinedPositionBinData = combinedPositionBinData;
   }
-  if (!swapForY && bin.amountX.isZero()) {
-    return {
-      amountIn: new (0, _anchor.BN)(0),
-      amountOut: new (0, _anchor.BN)(0),
-      fee: new (0, _anchor.BN)(0),
-      protocolFee: new (0, _anchor.BN)(0)
-    };
+  address() {
+    return this.positionAddress;
   }
-  let maxAmountOut;
-  let maxAmountIn;
-  if (swapForY) {
-    maxAmountOut = bin.amountY;
-    maxAmountIn = shlDiv(bin.amountY, bin.price, SCALE_OFFSET, 0 /* Up */);
-  } else {
-    maxAmountOut = bin.amountX;
-    maxAmountIn = mulShr(bin.amountX, bin.price, SCALE_OFFSET, 0 /* Up */);
+  totalClaimedRewards() {
+    return this.inner.totalClaimedRewards;
   }
-  const maxFee = computeFee(binStep, sParameter, vParameter, maxAmountIn);
-  maxAmountIn = maxAmountIn.add(maxFee);
-  let amountInWithFees;
-  let amountOut;
-  let fee;
-  let protocolFee;
-  if (inAmount.gt(maxAmountIn)) {
-    amountInWithFees = maxAmountIn;
-    amountOut = maxAmountOut;
-    fee = maxFee;
-    protocolFee = computeProtocolFee(maxFee, sParameter);
-  } else {
-    fee = computeFeeFromAmount(binStep, sParameter, vParameter, inAmount);
-    const amountInAfterFee = inAmount.sub(fee);
-    const computedOutAmount = getOutAmount(bin, amountInAfterFee, swapForY);
-    amountOut = computedOutAmount.gt(maxAmountOut) ? maxAmountOut : computedOutAmount;
-    protocolFee = computeProtocolFee(fee, sParameter);
-    amountInWithFees = inAmount;
+  feeOwner() {
+    return this.inner.feeOwner;
   }
-  return {
-    amountIn: amountInWithFees,
-    amountOut,
-    fee,
-    protocolFee
-  };
-}
-function getAmountIn(amountOut, price, swapForY) {
-  if (swapForY) {
-    return shlDiv(amountOut, price, SCALE_OFFSET, 0 /* Up */);
-  } else {
-    return mulShr(amountOut, price, SCALE_OFFSET, 0 /* Up */);
+  lockReleasePoint() {
+    return this.inner.lockReleasePoint;
   }
-}
-
-// src/dlmm/helpers/strategy.ts
-
-var DEFAULT_MAX_WEIGHT = 2e3;
-var DEFAULT_MIN_WEIGHT = 200;
-function toWeightSpotBalanced(minBinId, maxBinId) {
-  let distributions = [];
-  for (let i = minBinId; i <= maxBinId; i++) {
-    distributions.push({
-      binId: i,
-      weight: 1
-    });
+  operator() {
+    return this.inner.operator;
   }
-  return distributions;
-}
-function toWeightDescendingOrder(minBinId, maxBinId) {
-  let distributions = [];
-  for (let i = minBinId; i <= maxBinId; i++) {
-    distributions.push({
-      binId: i,
-      weight: maxBinId - i + 1
-    });
+  totalClaimedFeeYAmount() {
+    return this.inner.totalClaimedFeeYAmount;
   }
-  return distributions;
-}
-function toWeightAscendingOrder(minBinId, maxBinId) {
-  let distributions = [];
-  for (let i = minBinId; i <= maxBinId; i++) {
-    distributions.push({
-      binId: i,
-      weight: i - minBinId + 1
-    });
+  totalClaimedFeeXAmount() {
+    return this.inner.totalClaimedFeeXAmount;
   }
-  return distributions;
-}
-function toWeightCurve(minBinId, maxBinId, activeId) {
-  if (activeId < minBinId || activeId > maxBinId) {
-    throw "Invalid strategy params";
+  lbPair() {
+    return this.inner.lbPair;
   }
-  let maxWeight = DEFAULT_MAX_WEIGHT;
-  let minWeight = DEFAULT_MIN_WEIGHT;
-  let diffWeight = maxWeight - minWeight;
-  let diffMinWeight = activeId > minBinId ? Math.floor(diffWeight / (activeId - minBinId)) : 0;
-  let diffMaxWeight = maxBinId > activeId ? Math.floor(diffWeight / (maxBinId - activeId)) : 0;
-  let distributions = [];
-  for (let i = minBinId; i <= maxBinId; i++) {
-    if (i < activeId) {
-      distributions.push({
-        binId: i,
-        weight: maxWeight - (activeId - i) * diffMinWeight
-      });
-    } else if (i > activeId) {
-      distributions.push({
-        binId: i,
-        weight: maxWeight - (i - activeId) * diffMaxWeight
-      });
-    } else {
-      distributions.push({
-        binId: i,
-        weight: maxWeight
-      });
-    }
+  lowerBinId() {
+    return new (0, _bnjs2.default)(this.inner.lowerBinId);
   }
-  return distributions;
-}
-function toWeightBidAsk(minBinId, maxBinId, activeId) {
-  if (activeId < minBinId || activeId > maxBinId) {
-    throw "Invalid strategy params";
+  upperBinId() {
+    return new (0, _bnjs2.default)(this.inner.upperBinId);
   }
-  let maxWeight = DEFAULT_MAX_WEIGHT;
-  let minWeight = DEFAULT_MIN_WEIGHT;
-  let diffWeight = maxWeight - minWeight;
-  let diffMinWeight = activeId > minBinId ? Math.floor(diffWeight / (activeId - minBinId)) : 0;
-  let diffMaxWeight = maxBinId > activeId ? Math.floor(diffWeight / (maxBinId - activeId)) : 0;
-  let distributions = [];
-  for (let i = minBinId; i <= maxBinId; i++) {
-    if (i < activeId) {
-      distributions.push({
-        binId: i,
-        weight: minWeight + (activeId - i) * diffMinWeight
-      });
-    } else if (i > activeId) {
-      distributions.push({
-        binId: i,
-        weight: minWeight + (i - activeId) * diffMaxWeight
-      });
+  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 {
-      distributions.push({
-        binId: i,
-        weight: minWeight
-      });
+      const lowerBinArrayIndex = binIdToBinArrayIndex(this.lowerBinId());
+      const upperBinArrayIndex = lowerBinArrayIndex.add(new (0, _bnjs2.default)(1));
+      return [lowerBinArrayIndex, upperBinArrayIndex];
     }
   }
-  return distributions;
+  getBinArrayKeysCoverage(programId) {
+    return this.getBinArrayIndexesCoverage().map(
+      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
+    );
+  }
+  version() {
+    return 1 /* V2 */;
+  }
+  owner() {
+    return this.inner.owner;
+  }
+  width() {
+    return this.upperBinId().sub(this.lowerBinId()).add(new (0, _bnjs2.default)(1));
+  }
+};
+
+// src/dlmm/helpers/positions/index.ts
+function getBinArrayIndexesCoverage(lowerBinId, upperBinId) {
+  const lowerBinArrayIndex = binIdToBinArrayIndex(lowerBinId);
+  const upperBinArrayIndex = binIdToBinArrayIndex(upperBinId);
+  const binArrayIndexes = [];
+  for (let i = lowerBinArrayIndex.toNumber(); i <= upperBinArrayIndex.toNumber(); i++) {
+    binArrayIndexes.push(new (0, _bnjs2.default)(i));
+  }
+  return binArrayIndexes;
 }
-function toAmountsBothSideByStrategy(activeId, binStep, minBinId, maxBinId, amountX, amountY, amountXInActiveBin, amountYInActiveBin, strategyType, mintX, mintY, clock) {
-  const isSingleSideX = amountY.isZero();
-  switch (strategyType) {
-    case 0 /* Spot */: {
-      if (activeId < minBinId || activeId > maxBinId) {
-        const weights = toWeightSpotBalanced(minBinId, maxBinId);
-        return toAmountBothSide(
-          activeId,
-          binStep,
-          amountX,
-          amountY,
-          amountXInActiveBin,
-          amountYInActiveBin,
-          weights,
-          mintX,
-          mintY,
-          clock
-        );
-      }
-      const amountsInBin = [];
-      if (!isSingleSideX) {
-        if (minBinId <= activeId) {
-          const weights = toWeightSpotBalanced(minBinId, activeId);
-          const amounts = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId < maxBinId) {
-          const weights = toWeightSpotBalanced(activeId + 1, maxBinId);
-          const amounts = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      } else {
-        if (minBinId < activeId) {
-          const weights = toWeightSpotBalanced(minBinId, activeId - 1);
-          const amountsIntoBidSide = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amountsIntoBidSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId <= maxBinId) {
-          const weights = toWeightSpotBalanced(activeId, maxBinId);
-          const amountsIntoAskSide = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amountsIntoAskSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      }
-      return amountsInBin;
+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
+      };
     }
-    case 1 /* Curve */: {
-      if (activeId < minBinId) {
-        let weights = toWeightDescendingOrder(minBinId, maxBinId);
-        return toAmountBothSide(
-          activeId,
-          binStep,
-          amountX,
-          amountY,
-          amountXInActiveBin,
-          amountYInActiveBin,
-          weights,
-          mintX,
-          mintY,
-          clock
-        );
-      }
-      if (activeId > maxBinId) {
-        const weights = toWeightAscendingOrder(minBinId, maxBinId);
-        return toAmountBothSide(
-          activeId,
-          binStep,
-          amountX,
-          amountY,
-          amountXInActiveBin,
-          amountYInActiveBin,
-          weights,
-          mintX,
-          mintY,
-          clock
-        );
-      }
-      const amountsInBin = [];
-      if (!isSingleSideX) {
-        if (minBinId <= activeId) {
-          const weights = toWeightAscendingOrder(minBinId, activeId);
-          const amounts = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId < maxBinId) {
-          const weights = toWeightDescendingOrder(activeId + 1, maxBinId);
-          const amounts = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      } else {
-        if (minBinId < activeId) {
-          const weights = toWeightAscendingOrder(minBinId, activeId - 1);
-          const amountsIntoBidSide = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amountsIntoBidSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId <= maxBinId) {
-          const weights = toWeightDescendingOrder(activeId, maxBinId);
-          const amountsIntoAskSide = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amountsIntoAskSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      }
-      return amountsInBin;
-    }
-    case 2 /* BidAsk */: {
-      if (activeId < minBinId) {
-        const weights = toWeightAscendingOrder(minBinId, maxBinId);
-        return toAmountBothSide(
-          activeId,
-          binStep,
-          amountX,
-          amountY,
-          amountXInActiveBin,
-          amountYInActiveBin,
-          weights,
-          mintX,
-          mintY,
-          clock
-        );
-      }
-      if (activeId > maxBinId) {
-        const weights = toWeightDescendingOrder(minBinId, maxBinId);
-        return toAmountBothSide(
-          activeId,
-          binStep,
-          amountX,
-          amountY,
-          amountXInActiveBin,
-          amountYInActiveBin,
-          weights,
-          mintX,
-          mintY,
-          clock
-        );
-      }
-      const amountsInBin = [];
-      if (!isSingleSideX) {
-        if (minBinId <= activeId) {
-          const weights = toWeightDescendingOrder(minBinId, activeId);
-          const amounts = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId < maxBinId) {
-          const weights = toWeightAscendingOrder(activeId + 1, maxBinId);
-          const amounts = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amounts) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      } else {
-        if (minBinId < activeId) {
-          const weights = toWeightDescendingOrder(minBinId, activeId - 1);
-          const amountsIntoBidSide = toAmountBidSide(
-            activeId,
-            amountY,
-            weights,
-            mintY,
-            clock
-          );
-          for (let bin of amountsIntoBidSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: new (0, _anchor.BN)(0),
-              amountY: bin.amount
-            });
-          }
-        }
-        if (activeId <= maxBinId) {
-          const weights = toWeightAscendingOrder(activeId, maxBinId);
-          const amountsIntoAskSide = toAmountAskSide(
-            activeId,
-            binStep,
-            amountX,
-            weights,
-            mintX,
-            clock
-          );
-          for (let bin of amountsIntoAskSide) {
-            amountsInBin.push({
-              binId: bin.binId,
-              amountX: bin.amount,
-              amountY: new (0, _anchor.BN)(0)
-            });
-          }
-        }
-      }
-      return amountsInBin;
-    }
-  }
+  );
 }
-function autoFillYByStrategy(activeId, binStep, amountX, amountXInActiveBin, amountYInActiveBin, minBinId, maxBinId, strategyType) {
-  switch (strategyType) {
-    case 0 /* Spot */: {
-      let weights = toWeightSpotBalanced(minBinId, maxBinId);
-      return autoFillYByWeight(
-        activeId,
-        binStep,
-        amountX,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
-    case 1 /* Curve */: {
-      let weights = toWeightCurve(minBinId, maxBinId, activeId);
-      return autoFillYByWeight(
-        activeId,
-        binStep,
-        amountX,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
-    case 2 /* BidAsk */: {
-      let weights = toWeightBidAsk(minBinId, maxBinId, activeId);
-      return autoFillYByWeight(
-        activeId,
-        binStep,
-        amountX,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
-  }
+function getPositionLowerUpperBinIdWithLiquidity(position) {
+  const binWithLiquidity = position.positionBinData.filter(
+    (b) => !new (0, _bnjs2.default)(b.binLiquidity).isZero() || !new (0, _bnjs2.default)(b.positionFeeXAmount.toString()).isZero() || !new (0, _bnjs2.default)(b.positionFeeYAmount.toString()).isZero() || !new (0, _bnjs2.default)(b.positionRewardAmount[0].toString()).isZero() || !new (0, _bnjs2.default)(b.positionRewardAmount[1].toString()).isZero()
+  );
+  return binWithLiquidity.length > 0 ? {
+    lowerBinId: new (0, _bnjs2.default)(binWithLiquidity[0].binId),
+    upperBinId: new (0, _bnjs2.default)(binWithLiquidity[binWithLiquidity.length - 1].binId)
+  } : null;
 }
-function autoFillXByStrategy(activeId, binStep, amountY, amountXInActiveBin, amountYInActiveBin, minBinId, maxBinId, strategyType) {
-  switch (strategyType) {
-    case 0 /* Spot */: {
-      let weights = toWeightSpotBalanced(minBinId, maxBinId);
-      return autoFillXByWeight(
-        activeId,
-        binStep,
-        amountY,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
-    case 1 /* Curve */: {
-      let weights = toWeightCurve(minBinId, maxBinId, activeId);
-      return autoFillXByWeight(
-        activeId,
-        binStep,
-        amountY,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
-    case 2 /* BidAsk */: {
-      let weights = toWeightBidAsk(minBinId, maxBinId, activeId);
-      return autoFillXByWeight(
-        activeId,
-        binStep,
-        amountY,
-        amountXInActiveBin,
-        amountYInActiveBin,
-        weights
-      );
-    }
+function isPositionNoFee(position) {
+  return position.feeX.isZero() && position.feeY.isZero();
+}
+function isPositionNoReward(position) {
+  return position.rewardOne.isZero() && position.rewardTwo.isZero();
+}
+function chunkBinRange(minBinId, maxBinId) {
+  const chunkedBinRange = [];
+  let startBinId = minBinId;
+  while (startBinId <= maxBinId) {
+    const endBinId = Math.min(
+      startBinId + DEFAULT_BIN_PER_POSITION.toNumber() - 1,
+      maxBinId
+    );
+    chunkedBinRange.push({
+      lowerBinId: startBinId,
+      upperBinId: endBinId
+    });
+    startBinId += DEFAULT_BIN_PER_POSITION.toNumber();
   }
+  return chunkedBinRange;
 }
-function toStrategyParameters({
-  maxBinId,
-  minBinId,
-  strategyType,
-  singleSidedX
-}) {
-  const parameteres = new Array(64).fill(0);
-  const favorSide = singleSidedX ? 1 : 0;
-  parameteres[0] = favorSide;
-  switch (strategyType) {
-    case 0 /* Spot */: {
-      return {
-        minBinId,
-        maxBinId,
-        strategyType: { spotImBalanced: {} },
-        parameteres
-      };
-    }
-    case 1 /* Curve */: {
-      return {
-        minBinId,
-        maxBinId,
-        strategyType: { curveImBalanced: {} },
-        parameteres
-      };
-    }
-    case 2 /* BidAsk */: {
-      return {
-        minBinId,
-        maxBinId,
-        strategyType: { bidAskImBalanced: {} },
-        parameteres
-      };
-    }
+async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
+  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
+  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
+  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
+    return 0;
+  } else {
+    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
+      DEFAULT_BIN_PER_POSITION
+    );
+    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
+    const [minimumLamports, rentExemptionLamports] = await Promise.all([
+      connection.getMinimumBalanceForRentExemption(0),
+      connection.getMinimumBalanceForRentExemption(expandSize)
+    ]);
+    return rentExemptionLamports - minimumLamports;
   }
 }
-
-// src/dlmm/helpers/lbPair.ts
-
-
-async function getTokensMintFromPoolAddress(connection, poolAddress, opt) {
-  const program = createProgram(connection, opt);
-  const poolAccount = await program.account.lbPair.fetchNullable(
-    new (0, _web3js.PublicKey)(poolAddress)
-  );
-  if (!poolAccount)
-    throw new Error("Pool account not found");
-  return {
-    tokenXMint: poolAccount.tokenXMint,
-    tokenYMint: poolAccount.tokenYMint
-  };
+function getExtendedPositionBinCount(minBinId, maxBinId) {
+  const width = maxBinId.sub(minBinId).addn(1);
+  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
+  return extended.lte(new (0, _bnjs2.default)(0)) ? new (0, _bnjs2.default)(0) : extended;
 }
-function getTokenProgramId(lbPairState) {
-  const getTokenProgramIdByFlag = (flag) => {
-    return flag == 0 ? _spltoken.TOKEN_PROGRAM_ID : _spltoken.TOKEN_2022_PROGRAM_ID;
-  };
-  return {
-    tokenXProgram: getTokenProgramIdByFlag(lbPairState.tokenMintXProgramFlag),
-    tokenYProgram: getTokenProgramIdByFlag(lbPairState.tokenMintYProgramFlag)
-  };
+function decodeExtendedPosition(base, program, bytes) {
+  const width = base.upperBinId - base.lowerBinId + 1;
+  const extendedWidth = width - DEFAULT_BIN_PER_POSITION.toNumber();
+  const extendedPosition = [];
+  for (let i = 0; i < extendedWidth; i++) {
+    const offset = i * POSITION_BIN_DATA_SIZE;
+    const data = bytes.subarray(offset, offset + POSITION_BIN_DATA_SIZE);
+    const decodedPositionBinData = program.coder.types.decode(
+      // TODO: Find a type safe way
+      "positionBinData",
+      data
+    );
+    extendedPosition.push(decodedPositionBinData);
+  }
+  return extendedPosition;
 }
 
 // src/dlmm/helpers/rebalance/rebalancePosition.ts
 
 
 
-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();
+
+// src/dlmm/helpers/fee.ts
+
+function getBaseFee(binStep, sParameter) {
+  return new (0, _anchor.BN)(sParameter.baseFactor).mul(new (0, _anchor.BN)(binStep)).mul(new (0, _anchor.BN)(10)).mul(new (0, _anchor.BN)(10).pow(new (0, _anchor.BN)(sParameter.baseFeePowerFactor)));
+}
+function getVariableFee(binStep, sParameter, vParameter) {
+  if (sParameter.variableFeeControl > 0) {
+    const square_vfa_bin = new (0, _anchor.BN)(vParameter.volatilityAccumulator).mul(new (0, _anchor.BN)(binStep)).pow(new (0, _anchor.BN)(2));
+    const v_fee = new (0, _anchor.BN)(sParameter.variableFeeControl).mul(square_vfa_bin);
+    return v_fee.add(new (0, _anchor.BN)(99999999999)).div(new (0, _anchor.BN)(1e11));
   }
-  return {
-    bitFlag,
-    x0,
-    y0,
-    deltaX,
-    deltaY
-  };
+  return new (0, _anchor.BN)(0);
 }
-function toRebalancePositionBinData(positionData) {
-  return positionData.positionBinData.map(
-    ({
-      binId,
-      price,
-      pricePerToken,
-      positionXAmount,
-      positionYAmount,
-      positionFeeXAmount,
-      positionFeeYAmount,
-      positionRewardAmount
-    }) => {
-      return {
-        binId,
-        price,
-        pricePerToken,
-        amountX: new (0, _bnjs2.default)(positionXAmount),
-        amountY: new (0, _bnjs2.default)(positionYAmount),
-        claimableRewardAmount: positionRewardAmount.map(
-          (amount) => new (0, _bnjs2.default)(amount)
-        ),
-        claimableFeeXAmount: new (0, _bnjs2.default)(positionFeeXAmount),
-        claimableFeeYAmount: new (0, _bnjs2.default)(positionFeeYAmount)
-      };
-    }
+function getTotalFee(binStep, sParameter, vParameter) {
+  const totalFee = getBaseFee(binStep, sParameter).add(
+    getVariableFee(binStep, sParameter, vParameter)
   );
+  return totalFee.gt(MAX_FEE_RATE) ? MAX_FEE_RATE : totalFee;
 }
-function getDepositBinIds(activeId, deposits) {
-  const uniqueBinId = /* @__PURE__ */ new Set();
-  for (const { minDeltaId, maxDeltaId } of deposits) {
-    const minBinId = activeId.add(minDeltaId);
-    const maxBinId = activeId.add(maxDeltaId);
-    for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
-      uniqueBinId.add(binId);
-    }
-  }
-  const binIds = Array.from(uniqueBinId);
-  binIds.sort((a, b) => a - b);
-  return binIds;
+function computeFee(binStep, sParameter, vParameter, inAmount) {
+  const totalFee = getTotalFee(binStep, sParameter, vParameter);
+  const denominator = FEE_PRECISION.sub(totalFee);
+  return inAmount.mul(totalFee).add(denominator).sub(new (0, _anchor.BN)(1)).div(denominator);
 }
-function findMinMaxBinIdWithLiquidity(rebalancePositionBinData) {
-  let minBinId = null;
-  let maxBinId = null;
-  for (const binData of rebalancePositionBinData) {
-    if (binData.amountX.isZero() && binData.amountY.isZero() && binData.claimableFeeXAmount.isZero() && binData.claimableFeeYAmount.isZero() && binData.claimableRewardAmount.every((amount) => amount.isZero())) {
-      continue;
-    }
-    if (minBinId == null || binData.binId < minBinId) {
-      minBinId = binData.binId;
-    }
-    if (maxBinId == null || binData.binId > maxBinId) {
-      maxBinId = binData.binId;
-    }
-  }
-  return [minBinId, maxBinId];
+function computeFeeFromAmount(binStep, sParameter, vParameter, inAmountWithFees) {
+  const totalFee = getTotalFee(binStep, sParameter, vParameter);
+  return inAmountWithFees.mul(totalFee).add(FEE_PRECISION.sub(new (0, _anchor.BN)(1))).div(FEE_PRECISION);
 }
-function onlyDepositToBidSide(maxDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return maxDeltaId.lt(new (0, _bnjs2.default)(0));
-  }
-  return maxDeltaId.lte(new (0, _bnjs2.default)(0));
+function computeProtocolFee(feeAmount, sParameter) {
+  return feeAmount.mul(new (0, _anchor.BN)(sParameter.protocolShare)).div(new (0, _anchor.BN)(BASIS_POINT_MAX));
 }
-function onlyDepositToAskSide(minDeltaId, favorXInActiveBin) {
-  if (favorXInActiveBin) {
-    return minDeltaId.gte(new (0, _bnjs2.default)(0));
+function swapExactOutQuoteAtBin(bin, binStep, sParameter, vParameter, outAmount, swapForY) {
+  if (swapForY && bin.amountY.isZero()) {
+    return {
+      amountIn: new (0, _anchor.BN)(0),
+      amountOut: new (0, _anchor.BN)(0),
+      fee: new (0, _anchor.BN)(0),
+      protocolFee: new (0, _anchor.BN)(0)
+    };
   }
-  return minDeltaId.gt(new (0, _bnjs2.default)(0));
-}
-function getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0) {
+  if (!swapForY && bin.amountX.isZero()) {
+    return {
+      amountIn: new (0, _anchor.BN)(0),
+      amountOut: new (0, _anchor.BN)(0),
+      fee: new (0, _anchor.BN)(0),
+      protocolFee: new (0, _anchor.BN)(0)
+    };
+  }
+  let maxAmountOut;
+  let maxAmountIn;
+  if (swapForY) {
+    maxAmountOut = bin.amountY;
+    maxAmountIn = shlDiv(bin.amountY, bin.price, SCALE_OFFSET, 0 /* Up */);
+  } else {
+    maxAmountOut = bin.amountX;
+    maxAmountIn = mulShr(bin.amountX, bin.price, SCALE_OFFSET, 0 /* Up */);
+  }
+  if (outAmount.gte(maxAmountOut)) {
+    const maxFee = computeFee(binStep, sParameter, vParameter, maxAmountIn);
+    const protocolFee = computeProtocolFee(maxFee, sParameter);
+    return {
+      amountIn: maxAmountIn,
+      amountOut: maxAmountOut,
+      fee: maxFee,
+      protocolFee
+    };
+  } else {
+    const amountIn = getAmountIn(outAmount, bin.price, swapForY);
+    const fee = computeFee(binStep, sParameter, vParameter, amountIn);
+    const protocolFee = computeProtocolFee(fee, sParameter);
+    return {
+      amountIn,
+      amountOut: outAmount,
+      fee,
+      protocolFee
+    };
+  }
+}
+function swapExactInQuoteAtBin(bin, binStep, sParameter, vParameter, inAmount, swapForY) {
+  if (swapForY && bin.amountY.isZero()) {
+    return {
+      amountIn: new (0, _anchor.BN)(0),
+      amountOut: new (0, _anchor.BN)(0),
+      fee: new (0, _anchor.BN)(0),
+      protocolFee: new (0, _anchor.BN)(0)
+    };
+  }
+  if (!swapForY && bin.amountX.isZero()) {
+    return {
+      amountIn: new (0, _anchor.BN)(0),
+      amountOut: new (0, _anchor.BN)(0),
+      fee: new (0, _anchor.BN)(0),
+      protocolFee: new (0, _anchor.BN)(0)
+    };
+  }
+  let maxAmountOut;
+  let maxAmountIn;
+  if (swapForY) {
+    maxAmountOut = bin.amountY;
+    maxAmountIn = shlDiv(bin.amountY, bin.price, SCALE_OFFSET, 0 /* Up */);
+  } else {
+    maxAmountOut = bin.amountX;
+    maxAmountIn = mulShr(bin.amountX, bin.price, SCALE_OFFSET, 0 /* Up */);
+  }
+  const maxFee = computeFee(binStep, sParameter, vParameter, maxAmountIn);
+  maxAmountIn = maxAmountIn.add(maxFee);
+  let amountInWithFees;
+  let amountOut;
+  let fee;
+  let protocolFee;
+  if (inAmount.gt(maxAmountIn)) {
+    amountInWithFees = maxAmountIn;
+    amountOut = maxAmountOut;
+    fee = maxFee;
+    protocolFee = computeProtocolFee(maxFee, sParameter);
+  } else {
+    fee = computeFeeFromAmount(binStep, sParameter, vParameter, inAmount);
+    const amountInAfterFee = inAmount.sub(fee);
+    const computedOutAmount = getOutAmount(bin, amountInAfterFee, swapForY);
+    amountOut = computedOutAmount.gt(maxAmountOut) ? maxAmountOut : computedOutAmount;
+    protocolFee = computeProtocolFee(fee, sParameter);
+    amountInWithFees = inAmount;
+  }
+  return {
+    amountIn: amountInWithFees,
+    amountOut,
+    fee,
+    protocolFee
+  };
+}
+function getAmountIn(amountOut, price, swapForY) {
+  if (swapForY) {
+    return shlDiv(amountOut, price, SCALE_OFFSET, 0 /* Up */);
+  } else {
+    return mulShr(amountOut, price, SCALE_OFFSET, 0 /* Up */);
+  }
+}
+
+// src/dlmm/helpers/rebalance/rebalancePosition.ts
+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 (0, _bnjs2.default)(positionXAmount),
+        amountY: new (0, _bnjs2.default)(positionYAmount),
+        claimableRewardAmount: positionRewardAmount.map(
+          (amount) => new (0, _bnjs2.default)(amount)
+        ),
+        claimableFeeXAmount: new (0, _bnjs2.default)(positionFeeXAmount),
+        claimableFeeYAmount: new (0, _bnjs2.default)(positionFeeYAmount)
+      };
+    }
+  );
+}
+function getDepositBinIds(activeId, deposits) {
+  const uniqueBinId = /* @__PURE__ */ new Set();
+  for (const { minDeltaId, maxDeltaId } of deposits) {
+    const minBinId = activeId.add(minDeltaId);
+    const maxBinId = activeId.add(maxDeltaId);
+    for (let binId = minBinId.toNumber(); binId <= maxBinId.toNumber(); binId++) {
+      uniqueBinId.add(binId);
+    }
+  }
+  const binIds = Array.from(uniqueBinId);
+  binIds.sort((a, b) => a - b);
+  return binIds;
+}
+function findMinMaxBinIdWithLiquidity(rebalancePositionBinData) {
+  let minBinId = null;
+  let maxBinId = null;
+  for (const binData of rebalancePositionBinData) {
+    if (binData.amountX.isZero() && binData.amountY.isZero() && binData.claimableFeeXAmount.isZero() && binData.claimableFeeYAmount.isZero() && binData.claimableRewardAmount.every((amount) => amount.isZero())) {
+      continue;
+    }
+    if (minBinId == null || binData.binId < minBinId) {
+      minBinId = binData.binId;
+    }
+    if (maxBinId == null || binData.binId > maxBinId) {
+      maxBinId = binData.binId;
+    }
+  }
+  return [minBinId, maxBinId];
+}
+function onlyDepositToBidSide(maxDeltaId, favorXInActiveBin) {
+  if (favorXInActiveBin) {
+    return maxDeltaId.lt(new (0, _bnjs2.default)(0));
+  }
+  return maxDeltaId.lte(new (0, _bnjs2.default)(0));
+}
+function onlyDepositToAskSide(minDeltaId, favorXInActiveBin) {
+  if (favorXInActiveBin) {
+    return minDeltaId.gte(new (0, _bnjs2.default)(0));
+  }
+  return minDeltaId.gt(new (0, _bnjs2.default)(0));
+}
+function getAmountInBinsBidSide(activeId, minDeltaId, maxDeltaId, deltaY, y0) {
   const amountInBins = [];
   const minBinId = activeId.add(minDeltaId);
   const maxBinId = activeId.add(maxDeltaId);
@@ -13026,161 +12709,702 @@ function getAutoFillAmountByRebalancedPosition(rebalancePosition, strategyType)
       activeIdIndex = idx;
     }
   }
-  if (liquidityInAskSide.gt(liquidityInBidSide)) {
-    const minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
-    let maxBinId;
-    if (activeIdIndex == -1) {
-      maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
-    } else {
-      maxBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+  if (liquidityInAskSide.gt(liquidityInBidSide)) {
+    const minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
+    let maxBinId;
+    if (activeIdIndex == -1) {
+      maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
+    } else {
+      maxBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+    }
+    const minDeltaId = minBinId - lbPair.activeId;
+    const maxDeltaId = maxBinId - lbPair.activeId;
+    const { amountY } = builder.suggestBalancedYParametersFromX(
+      new (0, _bnjs2.default)(lbPair.activeId),
+      new (0, _bnjs2.default)(lbPair.binStep),
+      favorXInActiveBin,
+      new (0, _bnjs2.default)(minDeltaId),
+      new (0, _bnjs2.default)(maxDeltaId),
+      liquidityInAskSide
+    );
+    const [_, positionAmountY] = rebalancePosition.totalAmounts();
+    return {
+      amount: _bnjs2.default.max(amountY.sub(positionAmountY), new (0, _bnjs2.default)(0)),
+      isBidSide: true
+    };
+  } else if (liquidityInAskSide.lt(liquidityInBidSide)) {
+    const maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
+    let minBinId;
+    if (activeIdIndex == -1) {
+      minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
+    } else {
+      minBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+    }
+    const minDeltaId = minBinId - lbPair.activeId;
+    const maxDeltaId = maxBinId - lbPair.activeId;
+    const { amountX } = builder.suggestBalancedXParametersFromY(
+      new (0, _bnjs2.default)(lbPair.activeId),
+      new (0, _bnjs2.default)(lbPair.binStep),
+      favorXInActiveBin,
+      new (0, _bnjs2.default)(minDeltaId),
+      new (0, _bnjs2.default)(maxDeltaId),
+      liquidityInBidSide
+    );
+    const [positionAmountX] = rebalancePosition.totalAmounts();
+    return {
+      amount: _bnjs2.default.max(amountX.sub(positionAmountX), new (0, _bnjs2.default)(0)),
+      isBidSide: false
+    };
+  } else {
+    return {
+      amount: new (0, _bnjs2.default)(0),
+      isBidSide: false
+    };
+  }
+}
+function suggestBalancedYParametersFromX(x0, deltaX, minDeltaId, maxDeltaId, activeId, binStep, favorXInActiveBin, builder) {
+  const startDeltaIdAskSide = favorXInActiveBin ? new (0, _bnjs2.default)(0) : new (0, _bnjs2.default)(1);
+  if (minDeltaId.gte(startDeltaIdAskSide)) {
+    return {
+      base: new (0, _bnjs2.default)(0),
+      delta: new (0, _bnjs2.default)(0),
+      amountY: new (0, _bnjs2.default)(0)
+    };
+  }
+  const minXDeltaId = startDeltaIdAskSide;
+  const maxXDeltaId = maxDeltaId;
+  const amountXInBins = toAmountIntoBins(
+    activeId,
+    minXDeltaId,
+    maxXDeltaId,
+    deltaX,
+    new (0, _bnjs2.default)(0),
+    x0,
+    new (0, _bnjs2.default)(0),
+    binStep,
+    favorXInActiveBin
+  );
+  const totalAmountXInQuote = amountXInBins.reduce((acc, bin) => {
+    const price = getPriceOfBinByBinId(
+      bin.binId.toNumber(),
+      binStep.toNumber()
+    );
+    return acc.add(price.mul(new (0, _decimaljs2.default)(bin.amountX.toString())));
+  }, new (0, _decimaljs2.default)(0));
+  const totalAmountXInQuoteBN = new (0, _bnjs2.default)(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 {
+      x0: new (0, _bnjs2.default)(0),
+      y0: new (0, _bnjs2.default)(0),
+      deltaX: new (0, _bnjs2.default)(0),
+      deltaY: new (0, _bnjs2.default)(0)
+    };
+  }
+  const depositOnlyY = maxDeltaId.lt(new (0, _bnjs2.default)(0)) || maxDeltaId.isZero() && !favorXInActiveId;
+  const depositOnlyX = minDeltaId.gt(new (0, _bnjs2.default)(0)) || minDeltaId.isZero() && favorXInActiveId;
+  if (depositOnlyY) {
+    const { base, delta } = strategyParameterBuilder.findYParameters(
+      amountY,
+      minDeltaId,
+      maxDeltaId,
+      activeId
+    );
+    return {
+      x0: new (0, _bnjs2.default)(0),
+      deltaX: new (0, _bnjs2.default)(0),
+      y0: base,
+      deltaY: delta
+    };
+  }
+  if (depositOnlyX) {
+    const { base, delta } = strategyParameterBuilder.findXParameters(
+      amountX,
+      minDeltaId,
+      maxDeltaId,
+      binStep,
+      activeId
+    );
+    return {
+      x0: base,
+      deltaX: delta,
+      y0: new (0, _bnjs2.default)(0),
+      deltaY: new (0, _bnjs2.default)(0)
+    };
+  }
+  const maxDeltaIdBidSide = favorXInActiveId ? new (0, _bnjs2.default)(-1) : new (0, _bnjs2.default)(0);
+  const minDeltaIdAskSide = favorXInActiveId ? new (0, _bnjs2.default)(0) : new (0, _bnjs2.default)(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/lbPair.ts
+
+
+async function getTokensMintFromPoolAddress(connection, poolAddress, opt) {
+  const program = createProgram(connection, opt);
+  const poolAccount = await program.account.lbPair.fetchNullable(
+    new (0, _web3js.PublicKey)(poolAddress)
+  );
+  if (!poolAccount)
+    throw new Error("Pool account not found");
+  return {
+    tokenXMint: poolAccount.tokenXMint,
+    tokenYMint: poolAccount.tokenYMint
+  };
+}
+function getTokenProgramId(lbPairState) {
+  const getTokenProgramIdByFlag = (flag) => {
+    return flag == 0 ? _spltoken.TOKEN_PROGRAM_ID : _spltoken.TOKEN_2022_PROGRAM_ID;
+  };
+  return {
+    tokenXProgram: getTokenProgramIdByFlag(lbPairState.tokenMintXProgramFlag),
+    tokenYProgram: getTokenProgramIdByFlag(lbPairState.tokenMintYProgramFlag)
+  };
+}
+
+// src/dlmm/helpers/strategy.ts
+
+var DEFAULT_MAX_WEIGHT = 2e3;
+var DEFAULT_MIN_WEIGHT = 200;
+function toWeightSpotBalanced(minBinId, maxBinId) {
+  let distributions = [];
+  for (let i = minBinId; i <= maxBinId; i++) {
+    distributions.push({
+      binId: i,
+      weight: 1
+    });
+  }
+  return distributions;
+}
+function toWeightDescendingOrder(minBinId, maxBinId) {
+  let distributions = [];
+  for (let i = minBinId; i <= maxBinId; i++) {
+    distributions.push({
+      binId: i,
+      weight: maxBinId - i + 1
+    });
+  }
+  return distributions;
+}
+function toWeightAscendingOrder(minBinId, maxBinId) {
+  let distributions = [];
+  for (let i = minBinId; i <= maxBinId; i++) {
+    distributions.push({
+      binId: i,
+      weight: i - minBinId + 1
+    });
+  }
+  return distributions;
+}
+function toWeightCurve(minBinId, maxBinId, activeId) {
+  if (activeId < minBinId || activeId > maxBinId) {
+    throw "Invalid strategy params";
+  }
+  let maxWeight = DEFAULT_MAX_WEIGHT;
+  let minWeight = DEFAULT_MIN_WEIGHT;
+  let diffWeight = maxWeight - minWeight;
+  let diffMinWeight = activeId > minBinId ? Math.floor(diffWeight / (activeId - minBinId)) : 0;
+  let diffMaxWeight = maxBinId > activeId ? Math.floor(diffWeight / (maxBinId - activeId)) : 0;
+  let distributions = [];
+  for (let i = minBinId; i <= maxBinId; i++) {
+    if (i < activeId) {
+      distributions.push({
+        binId: i,
+        weight: maxWeight - (activeId - i) * diffMinWeight
+      });
+    } else if (i > activeId) {
+      distributions.push({
+        binId: i,
+        weight: maxWeight - (i - activeId) * diffMaxWeight
+      });
+    } else {
+      distributions.push({
+        binId: i,
+        weight: maxWeight
+      });
+    }
+  }
+  return distributions;
+}
+function toWeightBidAsk(minBinId, maxBinId, activeId) {
+  if (activeId < minBinId || activeId > maxBinId) {
+    throw "Invalid strategy params";
+  }
+  let maxWeight = DEFAULT_MAX_WEIGHT;
+  let minWeight = DEFAULT_MIN_WEIGHT;
+  let diffWeight = maxWeight - minWeight;
+  let diffMinWeight = activeId > minBinId ? Math.floor(diffWeight / (activeId - minBinId)) : 0;
+  let diffMaxWeight = maxBinId > activeId ? Math.floor(diffWeight / (maxBinId - activeId)) : 0;
+  let distributions = [];
+  for (let i = minBinId; i <= maxBinId; i++) {
+    if (i < activeId) {
+      distributions.push({
+        binId: i,
+        weight: minWeight + (activeId - i) * diffMinWeight
+      });
+    } else if (i > activeId) {
+      distributions.push({
+        binId: i,
+        weight: minWeight + (i - activeId) * diffMaxWeight
+      });
+    } else {
+      distributions.push({
+        binId: i,
+        weight: minWeight
+      });
+    }
+  }
+  return distributions;
+}
+function toAmountsBothSideByStrategy(activeId, binStep, minBinId, maxBinId, amountX, amountY, amountXInActiveBin, amountYInActiveBin, strategyType, mintX, mintY, clock) {
+  const isSingleSideX = amountY.isZero();
+  switch (strategyType) {
+    case 0 /* Spot */: {
+      if (activeId < minBinId || activeId > maxBinId) {
+        const weights = toWeightSpotBalanced(minBinId, maxBinId);
+        return toAmountBothSide(
+          activeId,
+          binStep,
+          amountX,
+          amountY,
+          amountXInActiveBin,
+          amountYInActiveBin,
+          weights,
+          mintX,
+          mintY,
+          clock
+        );
+      }
+      const amountsInBin = [];
+      if (!isSingleSideX) {
+        if (minBinId <= activeId) {
+          const weights = toWeightSpotBalanced(minBinId, activeId);
+          const amounts = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId < maxBinId) {
+          const weights = toWeightSpotBalanced(activeId + 1, maxBinId);
+          const amounts = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      } else {
+        if (minBinId < activeId) {
+          const weights = toWeightSpotBalanced(minBinId, activeId - 1);
+          const amountsIntoBidSide = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amountsIntoBidSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId <= maxBinId) {
+          const weights = toWeightSpotBalanced(activeId, maxBinId);
+          const amountsIntoAskSide = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amountsIntoAskSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      }
+      return amountsInBin;
+    }
+    case 1 /* Curve */: {
+      if (activeId < minBinId) {
+        let weights = toWeightDescendingOrder(minBinId, maxBinId);
+        return toAmountBothSide(
+          activeId,
+          binStep,
+          amountX,
+          amountY,
+          amountXInActiveBin,
+          amountYInActiveBin,
+          weights,
+          mintX,
+          mintY,
+          clock
+        );
+      }
+      if (activeId > maxBinId) {
+        const weights = toWeightAscendingOrder(minBinId, maxBinId);
+        return toAmountBothSide(
+          activeId,
+          binStep,
+          amountX,
+          amountY,
+          amountXInActiveBin,
+          amountYInActiveBin,
+          weights,
+          mintX,
+          mintY,
+          clock
+        );
+      }
+      const amountsInBin = [];
+      if (!isSingleSideX) {
+        if (minBinId <= activeId) {
+          const weights = toWeightAscendingOrder(minBinId, activeId);
+          const amounts = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId < maxBinId) {
+          const weights = toWeightDescendingOrder(activeId + 1, maxBinId);
+          const amounts = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      } else {
+        if (minBinId < activeId) {
+          const weights = toWeightAscendingOrder(minBinId, activeId - 1);
+          const amountsIntoBidSide = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amountsIntoBidSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId <= maxBinId) {
+          const weights = toWeightDescendingOrder(activeId, maxBinId);
+          const amountsIntoAskSide = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amountsIntoAskSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      }
+      return amountsInBin;
+    }
+    case 2 /* BidAsk */: {
+      if (activeId < minBinId) {
+        const weights = toWeightAscendingOrder(minBinId, maxBinId);
+        return toAmountBothSide(
+          activeId,
+          binStep,
+          amountX,
+          amountY,
+          amountXInActiveBin,
+          amountYInActiveBin,
+          weights,
+          mintX,
+          mintY,
+          clock
+        );
+      }
+      if (activeId > maxBinId) {
+        const weights = toWeightDescendingOrder(minBinId, maxBinId);
+        return toAmountBothSide(
+          activeId,
+          binStep,
+          amountX,
+          amountY,
+          amountXInActiveBin,
+          amountYInActiveBin,
+          weights,
+          mintX,
+          mintY,
+          clock
+        );
+      }
+      const amountsInBin = [];
+      if (!isSingleSideX) {
+        if (minBinId <= activeId) {
+          const weights = toWeightDescendingOrder(minBinId, activeId);
+          const amounts = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId < maxBinId) {
+          const weights = toWeightAscendingOrder(activeId + 1, maxBinId);
+          const amounts = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amounts) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      } else {
+        if (minBinId < activeId) {
+          const weights = toWeightDescendingOrder(minBinId, activeId - 1);
+          const amountsIntoBidSide = toAmountBidSide(
+            activeId,
+            amountY,
+            weights,
+            mintY,
+            clock
+          );
+          for (let bin of amountsIntoBidSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: new (0, _anchor.BN)(0),
+              amountY: bin.amount
+            });
+          }
+        }
+        if (activeId <= maxBinId) {
+          const weights = toWeightAscendingOrder(activeId, maxBinId);
+          const amountsIntoAskSide = toAmountAskSide(
+            activeId,
+            binStep,
+            amountX,
+            weights,
+            mintX,
+            clock
+          );
+          for (let bin of amountsIntoAskSide) {
+            amountsInBin.push({
+              binId: bin.binId,
+              amountX: bin.amount,
+              amountY: new (0, _anchor.BN)(0)
+            });
+          }
+        }
+      }
+      return amountsInBin;
+    }
+  }
+}
+function autoFillYByStrategy(activeId, binStep, amountX, amountXInActiveBin, amountYInActiveBin, minBinId, maxBinId, strategyType) {
+  switch (strategyType) {
+    case 0 /* Spot */: {
+      let weights = toWeightSpotBalanced(minBinId, maxBinId);
+      return autoFillYByWeight(
+        activeId,
+        binStep,
+        amountX,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
     }
-    const minDeltaId = minBinId - lbPair.activeId;
-    const maxDeltaId = maxBinId - lbPair.activeId;
-    const { amountY } = builder.suggestBalancedYParametersFromX(
-      new (0, _bnjs2.default)(lbPair.activeId),
-      new (0, _bnjs2.default)(lbPair.binStep),
-      favorXInActiveBin,
-      new (0, _bnjs2.default)(minDeltaId),
-      new (0, _bnjs2.default)(maxDeltaId),
-      liquidityInAskSide
-    );
-    const [_, positionAmountY] = rebalancePosition.totalAmounts();
-    return {
-      amount: _bnjs2.default.max(amountY.sub(positionAmountY), new (0, _bnjs2.default)(0)),
-      isBidSide: true
-    };
-  } else if (liquidityInAskSide.lt(liquidityInBidSide)) {
-    const maxBinId = rebalancePosition.rebalancePositionBinData[rebalancePosition.rebalancePositionBinData.length - 1].binId;
-    let minBinId;
-    if (activeIdIndex == -1) {
-      minBinId = rebalancePosition.rebalancePositionBinData[0].binId;
-    } else {
-      minBinId = rebalancePosition.rebalancePositionBinData[favorXInActiveBin ? activeIdIndex - 1 : activeIdIndex].binId;
+    case 1 /* Curve */: {
+      let weights = toWeightCurve(minBinId, maxBinId, activeId);
+      return autoFillYByWeight(
+        activeId,
+        binStep,
+        amountX,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
+    }
+    case 2 /* BidAsk */: {
+      let weights = toWeightBidAsk(minBinId, maxBinId, activeId);
+      return autoFillYByWeight(
+        activeId,
+        binStep,
+        amountX,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
     }
-    const minDeltaId = lbPair.activeId - minBinId;
-    const maxDeltaId = lbPair.activeId - maxBinId;
-    const { amountX } = builder.suggestBalancedXParametersFromY(
-      new (0, _bnjs2.default)(lbPair.activeId),
-      new (0, _bnjs2.default)(lbPair.binStep),
-      favorXInActiveBin,
-      new (0, _bnjs2.default)(minDeltaId),
-      new (0, _bnjs2.default)(maxDeltaId),
-      liquidityInBidSide
-    );
-    const [positionAmountX] = rebalancePosition.totalAmounts();
-    return {
-      amount: _bnjs2.default.max(amountX.sub(positionAmountX), new (0, _bnjs2.default)(0)),
-      isBidSide: false
-    };
-  } else {
-    return {
-      amount: new (0, _bnjs2.default)(0),
-      isBidSide: false
-    };
   }
 }
-function suggestBalancedYParametersFromX(x0, deltaX, minDeltaId, maxDeltaId, activeId, binStep, favorXInActiveBin, builder) {
-  const startDeltaIdAskSide = favorXInActiveBin ? new (0, _bnjs2.default)(0) : new (0, _bnjs2.default)(1);
-  if (minDeltaId.gte(startDeltaIdAskSide)) {
-    return {
-      base: new (0, _bnjs2.default)(0),
-      delta: new (0, _bnjs2.default)(0),
-      amountY: new (0, _bnjs2.default)(0)
-    };
+function autoFillXByStrategy(activeId, binStep, amountY, amountXInActiveBin, amountYInActiveBin, minBinId, maxBinId, strategyType) {
+  switch (strategyType) {
+    case 0 /* Spot */: {
+      let weights = toWeightSpotBalanced(minBinId, maxBinId);
+      return autoFillXByWeight(
+        activeId,
+        binStep,
+        amountY,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
+    }
+    case 1 /* Curve */: {
+      let weights = toWeightCurve(minBinId, maxBinId, activeId);
+      return autoFillXByWeight(
+        activeId,
+        binStep,
+        amountY,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
+    }
+    case 2 /* BidAsk */: {
+      let weights = toWeightBidAsk(minBinId, maxBinId, activeId);
+      return autoFillXByWeight(
+        activeId,
+        binStep,
+        amountY,
+        amountXInActiveBin,
+        amountYInActiveBin,
+        weights
+      );
+    }
   }
-  const minXDeltaId = startDeltaIdAskSide;
-  const maxXDeltaId = maxDeltaId;
-  const amountXInBins = toAmountIntoBins(
-    activeId,
-    minXDeltaId,
-    maxXDeltaId,
-    deltaX,
-    new (0, _bnjs2.default)(0),
-    x0,
-    new (0, _bnjs2.default)(0),
-    binStep,
-    favorXInActiveBin
-  );
-  const totalAmountXInQuote = amountXInBins.reduce((acc, bin) => {
-    const price = getPriceOfBinByBinId(
-      bin.binId.toNumber(),
-      binStep.toNumber()
-    );
-    return acc.add(price.mul(new (0, _decimaljs2.default)(bin.amountX.toString())));
-  }, new (0, _decimaljs2.default)(0));
-  const totalAmountXInQuoteBN = new (0, _bnjs2.default)(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 {
-      x0: new (0, _bnjs2.default)(0),
-      y0: new (0, _bnjs2.default)(0),
-      deltaX: new (0, _bnjs2.default)(0),
-      deltaY: new (0, _bnjs2.default)(0)
-    };
-  }
-  const depositOnlyY = maxDeltaId.lt(new (0, _bnjs2.default)(0)) || maxDeltaId.isZero() && !favorXInActiveId;
-  const depositOnlyX = minDeltaId.gt(new (0, _bnjs2.default)(0)) || minDeltaId.isZero() && favorXInActiveId;
-  if (depositOnlyY) {
-    const { base, delta } = strategyParameterBuilder.findYParameters(
-      amountY,
-      minDeltaId,
-      maxDeltaId,
-      activeId
-    );
-    return {
-      x0: new (0, _bnjs2.default)(0),
-      deltaX: new (0, _bnjs2.default)(0),
-      y0: base,
-      deltaY: delta
-    };
-  }
-  if (depositOnlyX) {
-    const { base, delta } = strategyParameterBuilder.findXParameters(
-      amountX,
-      minDeltaId,
-      maxDeltaId,
-      binStep,
-      activeId
-    );
-    return {
-      x0: base,
-      deltaX: delta,
-      y0: new (0, _bnjs2.default)(0),
-      deltaY: new (0, _bnjs2.default)(0)
-    };
-  }
-  const maxDeltaIdBidSide = favorXInActiveId ? new (0, _bnjs2.default)(-1) : new (0, _bnjs2.default)(0);
-  const minDeltaIdAskSide = favorXInActiveId ? new (0, _bnjs2.default)(0) : new (0, _bnjs2.default)(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
-  };
+function toStrategyParameters({
+  maxBinId,
+  minBinId,
+  strategyType,
+  singleSidedX
+}) {
+  const parameteres = new Array(64).fill(0);
+  const favorSide = singleSidedX ? 1 : 0;
+  parameteres[0] = favorSide;
+  switch (strategyType) {
+    case 0 /* Spot */: {
+      return {
+        minBinId,
+        maxBinId,
+        strategyType: { spotImBalanced: {} },
+        parameteres
+      };
+    }
+    case 1 /* Curve */: {
+      return {
+        minBinId,
+        maxBinId,
+        strategyType: { curveImBalanced: {} },
+        parameteres
+      };
+    }
+    case 2 /* BidAsk */: {
+      return {
+        minBinId,
+        maxBinId,
+        strategyType: { bidAskImBalanced: {} },
+        parameteres
+      };
+    }
+  }
 }
 
 // src/dlmm/helpers/index.ts
@@ -13285,359 +13509,403 @@ var unwrapSOLInstruction = async (owner, allowOwnerOffCurve = true) => {
   );
   if (wSolATAAccount) {
     const closedWrappedSolInstruction = _spltoken.createCloseAccountInstruction.call(void 0, 
-      wSolATAAccount,
-      owner,
-      owner,
-      [],
-      _spltoken.TOKEN_PROGRAM_ID
-    );
-    return closedWrappedSolInstruction;
-  }
-  return null;
-};
-async function chunkedGetMultipleAccountInfos(connection, pks, chunkSize = 100) {
-  const accountInfos = (await Promise.all(
-    chunks(pks, chunkSize).map(
-      (chunk) => connection.getMultipleAccountsInfo(chunk)
-    )
-  )).flat();
-  return accountInfos;
-}
-var getEstimatedComputeUnitUsageWithBuffer = async (connection, instructions, feePayer, buffer) => {
-  if (!buffer) {
-    buffer = 0.1;
-  }
-  buffer = Math.max(0, buffer);
-  buffer = Math.min(1, buffer);
-  const estimatedComputeUnitUsage = await getSimulationComputeUnits(
-    connection,
-    instructions,
-    feePayer,
-    []
-  );
-  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
-  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
-    extraComputeUnitBuffer = MAX_CU_BUFFER;
-  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
-    extraComputeUnitBuffer = MIN_CU_BUFFER;
-  }
-  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
-};
-var getEstimatedComputeUnitIxWithBuffer = async (connection, instructions, feePayer, buffer) => {
-  const units = await getEstimatedComputeUnitUsageWithBuffer(
-    connection,
-    instructions,
-    feePayer,
-    buffer
-  ).catch((error) => {
-    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
-    return 14e5;
-  });
-  return _web3js.ComputeBudgetProgram.setComputeUnitLimit({ units });
-};
-function createProgram(connection, opt) {
-  const cluster = _optionalChain([opt, 'optionalAccess', _43 => _43.cluster]) || "mainnet-beta";
-  const provider = new (0, _anchor.AnchorProvider)(
-    connection,
-    {},
-    _anchor.AnchorProvider.defaultOptions()
-  );
-  return new (0, _anchor.Program)(
-    { ...dlmm_default, address: LBCLMM_PROGRAM_IDS[cluster] },
-    provider
-  );
-}
-function decodeAccount(program, accountName, buffer) {
-  return program.coder.accounts.decode(accountName, buffer);
-}
-function getAccountDiscriminator(accountName) {
-  return _optionalChain([dlmm_default, 'access', _44 => _44.accounts, 'access', _45 => _45.find, 'call', _46 => _46(
-    (acc) => acc.name.toLowerCase() === accountName.toLowerCase()
-  ), 'optionalAccess', _47 => _47.discriminator]);
-}
-function capSlippagePercentage(slippage) {
-  if (slippage > 100) {
-    slippage = 100;
-  }
-  if (slippage < 0) {
-    slippage = 0;
-  }
-  return slippage;
-}
-
-// src/dlmm/helpers/accountFilters.ts
-var _bytes = require('@coral-xyz/anchor/dist/cjs/utils/bytes');
-var presetParameter2BinStepFilter = (binStep) => {
-  return {
-    memcmp: {
-      bytes: _bytes.bs58.encode(binStep.toArrayLike(Buffer, "le", 2)),
-      offset: 8
-    }
-  };
-};
-var presetParameter2BaseFactorFilter = (baseFactor) => {
-  return {
-    memcmp: {
-      bytes: _bytes.bs58.encode(baseFactor.toArrayLike(Buffer, "le", 2)),
-      offset: 8 + 2
-    }
-  };
-};
-var presetParameter2BaseFeePowerFactor = (baseFeePowerFactor) => {
-  return {
-    memcmp: {
-      bytes: _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: _bytes.bs58.encode(lbPair.toBuffer()),
-      offset: 8
-    }
-  };
-};
-var positionV2Filter = () => {
-  return {
-    memcmp: {
-      bytes: _bytes.bs58.encode(Buffer.from(getAccountDiscriminator("positionV2"))),
-      offset: 0
-    }
-  };
-};
-
-// src/dlmm/helpers/positions/index.ts
-
-
-// src/dlmm/helpers/positions/wrapper.ts
-
-function combineBaseAndExtendedPositionBinData(base, extended) {
-  const combinedLiquidityShares = base.liquidityShares;
-  const combinedRewardInfos = base.rewardInfos;
-  const combinedFeeInfos = base.feeInfos;
-  for (const binData of extended) {
-    combinedLiquidityShares.push(binData.liquidityShare);
-    combinedRewardInfos.push(binData.rewardInfo);
-    combinedFeeInfos.push(binData.feeInfo);
-  }
-  return {
-    liquidityShares: combinedLiquidityShares,
-    rewardInfos: combinedRewardInfos,
-    feeInfos: combinedFeeInfos
-  };
-}
-function wrapPosition(program, key, account) {
-  const disc = account.data.subarray(0, 8);
-  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
-    const state = decodeAccount(
-      program,
-      "positionV2",
-      account.data
-    );
-    const extended = decodeExtendedPosition(
-      state,
-      program,
-      account.data.subarray(8 + POSITION_MIN_SIZE)
-    );
-    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
-      state,
-      extended
-    );
-    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
-  } else {
-    throw new Error("Unknown position account");
-  }
-}
-var PositionV2Wrapper = class {
-  constructor(positionAddress, inner, extended, combinedPositionBinData) {
-    this.positionAddress = positionAddress;
-    this.inner = inner;
-    this.extended = extended;
-    this.combinedPositionBinData = combinedPositionBinData;
-  }
-  address() {
-    return this.positionAddress;
-  }
-  totalClaimedRewards() {
-    return this.inner.totalClaimedRewards;
-  }
-  feeOwner() {
-    return this.inner.feeOwner;
-  }
-  lockReleasePoint() {
-    return this.inner.lockReleasePoint;
-  }
-  operator() {
-    return this.inner.operator;
-  }
-  totalClaimedFeeYAmount() {
-    return this.inner.totalClaimedFeeYAmount;
-  }
-  totalClaimedFeeXAmount() {
-    return this.inner.totalClaimedFeeXAmount;
-  }
-  lbPair() {
-    return this.inner.lbPair;
-  }
-  lowerBinId() {
-    return new (0, _bnjs2.default)(this.inner.lowerBinId);
-  }
-  upperBinId() {
-    return new (0, _bnjs2.default)(this.inner.upperBinId);
-  }
-  liquidityShares() {
-    return this.combinedPositionBinData.liquidityShares;
-  }
-  rewardInfos() {
-    return this.combinedPositionBinData.rewardInfos;
-  }
-  feeInfos() {
-    return this.combinedPositionBinData.feeInfos;
-  }
-  lastUpdatedAt() {
-    return this.inner.lastUpdatedAt;
-  }
-  getBinArrayIndexesCoverage() {
-    const isExtended = this.extended.length > 0;
-    if (isExtended) {
-      return getBinArrayIndexesCoverage(this.lowerBinId(), this.upperBinId());
-    } else {
-      const lowerBinArrayIndex = binIdToBinArrayIndex(this.lowerBinId());
-      const upperBinArrayIndex = lowerBinArrayIndex.add(new (0, _bnjs2.default)(1));
-      return [lowerBinArrayIndex, upperBinArrayIndex];
-    }
-  }
-  getBinArrayKeysCoverage(programId) {
-    return this.getBinArrayIndexesCoverage().map(
-      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
+      wSolATAAccount,
+      owner,
+      owner,
+      [],
+      _spltoken.TOKEN_PROGRAM_ID
     );
+    return closedWrappedSolInstruction;
   }
-  version() {
-    return 1 /* V2 */;
-  }
-  owner() {
-    return this.inner.owner;
+  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;
   }
-  width() {
-    return this.upperBinId().sub(this.lowerBinId()).add(new (0, _bnjs2.default)(1));
+  buffer = Math.max(0, buffer);
+  buffer = Math.min(1, buffer);
+  const estimatedComputeUnitUsage = await getSimulationComputeUnits(
+    connection,
+    instructions,
+    feePayer,
+    []
+  );
+  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
+  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
+    extraComputeUnitBuffer = MAX_CU_BUFFER;
+  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
+    extraComputeUnitBuffer = MIN_CU_BUFFER;
   }
+  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
 };
-
-// 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 (0, _bnjs2.default)(i));
-  }
-  return binArrayIndexes;
-}
-function getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId) {
-  const binArrayIndexes = getBinArrayIndexesCoverage(lowerBinId, upperBinId);
-  return binArrayIndexes.map((index) => {
-    return deriveBinArray(lbPair, index, programId)[0];
+var getEstimatedComputeUnitIxWithBuffer = async (connection, instructions, feePayer, buffer) => {
+  const units = await getEstimatedComputeUnitUsageWithBuffer(
+    connection,
+    instructions,
+    feePayer,
+    buffer
+  ).catch((error) => {
+    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
+    return 14e5;
   });
-}
-function getBinArrayAccountMetasCoverage(lowerBinId, upperBinId, lbPair, programId) {
-  return getBinArrayKeysCoverage2(lowerBinId, upperBinId, lbPair, programId).map(
-    (key) => {
-      return {
-        pubkey: key,
-        isSigner: false,
-        isWritable: true
-      };
-    }
+  return _web3js.ComputeBudgetProgram.setComputeUnitLimit({ units });
+};
+function createProgram(connection, opt) {
+  const cluster = _optionalChain([opt, 'optionalAccess', _43 => _43.cluster]) || "mainnet-beta";
+  const provider = new (0, _anchor.AnchorProvider)(
+    connection,
+    {},
+    _anchor.AnchorProvider.defaultOptions()
   );
-}
-function getPositionLowerUpperBinIdWithLiquidity(position) {
-  const binWithLiquidity = position.positionBinData.filter(
-    (b) => !new (0, _bnjs2.default)(b.binLiquidity).isZero() || !new (0, _bnjs2.default)(b.positionFeeXAmount.toString()).isZero() || !new (0, _bnjs2.default)(b.positionFeeYAmount.toString()).isZero() || !new (0, _bnjs2.default)(b.positionRewardAmount[0].toString()).isZero() || !new (0, _bnjs2.default)(b.positionRewardAmount[1].toString()).isZero()
+  return new (0, _anchor.Program)(
+    { ...dlmm_default, address: LBCLMM_PROGRAM_IDS[cluster] },
+    provider
   );
-  return binWithLiquidity.length > 0 ? {
-    lowerBinId: new (0, _bnjs2.default)(binWithLiquidity[0].binId),
-    upperBinId: new (0, _bnjs2.default)(binWithLiquidity[binWithLiquidity.length - 1].binId)
-  } : null;
 }
-function isPositionNoFee(position) {
-  return position.feeX.isZero() && position.feeY.isZero();
+function decodeAccount(program, accountName, buffer) {
+  return program.coder.accounts.decode(accountName, buffer);
 }
-function isPositionNoReward(position) {
-  return position.rewardOne.isZero() && position.rewardTwo.isZero();
+function getAccountDiscriminator(accountName) {
+  return _optionalChain([dlmm_default, 'access', _44 => _44.accounts, 'access', _45 => _45.find, 'call', _46 => _46(
+    (acc) => acc.name.toLowerCase() === accountName.toLowerCase()
+  ), 'optionalAccess', _47 => _47.discriminator]);
 }
-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();
+function capSlippagePercentage(slippage) {
+  if (slippage > 100) {
+    slippage = 100;
   }
-  return chunkedBinRange;
-}
-async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
-  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
-  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
-  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
-    return 0;
-  } else {
-    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
-      DEFAULT_BIN_PER_POSITION
-    );
-    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
-    const [minimumLamports, rentExemptionLamports] = await Promise.all([
-      connection.getMinimumBalanceForRentExemption(0),
-      connection.getMinimumBalanceForRentExemption(expandSize)
-    ]);
-    return rentExemptionLamports - minimumLamports;
+  if (slippage < 0) {
+    slippage = 0;
   }
+  return slippage;
 }
-function getExtendedPositionBinCount(minBinId, maxBinId) {
-  const width = maxBinId.sub(minBinId).addn(1);
-  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
-  return extended.lte(new (0, _bnjs2.default)(0)) ? new (0, _bnjs2.default)(0) : extended;
+function getAndCapMaxActiveBinSlippage(slippagePercentage, binStep, maxActiveBinSlippage) {
+  return slippagePercentage ? Math.ceil(slippagePercentage / (binStep / 100)) : maxActiveBinSlippage;
 }
-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 getBinCount(minBinId, maxBinId) {
+  return maxBinId - minBinId + 1;
+}
+function getSlippageMaxAmount(amount, slippage) {
+  return slippage == 100 ? U64_MAX : amount.muln(100 + slippage).divn(100);
+}
+function getSlippageMinAmount(amount, slippage) {
+  return amount.muln(100 - slippage).divn(100);
+}
+function getPositionCountByBinCount(binCount) {
+  return Math.ceil(binCount / MAX_BINS_PER_POSITION.toNumber());
+}
+function resetUninvolvedLiquidityParams(minDeltaId, maxDeltaId, favorXInActiveId, params) {
+  const endBidSideDeltaId = favorXInActiveId ? new (0, _anchor.BN)(-1) : new (0, _anchor.BN)(0);
+  const startAskSideDeltaId = endBidSideDeltaId.addn(1);
+  let x0 = params.x0;
+  let y0 = params.y0;
+  let deltaX = params.deltaX;
+  let deltaY = params.deltaY;
+  if (maxDeltaId.lte(endBidSideDeltaId)) {
+    deltaX = new (0, _anchor.BN)(0);
+    x0 = new (0, _anchor.BN)(0);
+  }
+  if (minDeltaId.gte(startAskSideDeltaId)) {
+    deltaY = new (0, _anchor.BN)(0);
+    y0 = new (0, _anchor.BN)(0);
+  }
+  return {
+    x0,
+    y0,
+    deltaX,
+    deltaY
+  };
+}
+async function chunkDepositWithRebalanceEndpoint(dlmm, strategy, slippagePercentage, maxActiveBinSlippage, position, positionMinBinId, positionMaxBinId, liquidityStrategyParameters, owner, payer, simulateCU) {
+  const { slices, accounts: transferHookAccounts } = dlmm.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
+  const userTokenX = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
+    dlmm.lbPair.tokenXMint,
+    owner,
+    true,
+    dlmm.tokenX.owner
+  );
+  const userTokenY = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
+    dlmm.lbPair.tokenYMint,
+    owner,
+    true,
+    dlmm.tokenY.owner
+  );
+  const createUserTokenXIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+    payer,
+    userTokenX,
+    owner,
+    dlmm.lbPair.tokenXMint,
+    dlmm.tokenX.owner
+  );
+  const createUserTokenYIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+    payer,
+    userTokenY,
+    owner,
+    dlmm.lbPair.tokenYMint,
+    dlmm.tokenY.owner
+  );
+  const bitmapPubkey = deriveBinArrayBitmapExtension(
+    dlmm.pubkey,
+    dlmm.program.programId
+  )[0];
+  let calculatedAddLiquidityCU = 0;
+  const chunkedAddLiquidityIx = [];
+  const chunkedBinRange = chunkBinRange(positionMinBinId, positionMaxBinId);
+  const binArrayOrBitmapInitTracking = /* @__PURE__ */ new Set();
+  for (let i = 0; i < chunkedBinRange.length; i++) {
+    const chunkMinBinId = chunkedBinRange[i].lowerBinId;
+    const chunkMaxBinId = chunkedBinRange[i].upperBinId;
+    const initBinArrayIxs = [];
+    const initBitmapIxs = [];
+    const binArrayIndexes = getBinArrayIndexesCoverage(
+      new (0, _anchor.BN)(chunkMinBinId),
+      new (0, _anchor.BN)(chunkMaxBinId)
     );
-    extendedPosition.push(decodedPositionBinData);
+    const overflowDefaultBinArrayBitmap = binArrayIndexes.reduce(
+      (acc, binArrayIndex) => acc || isOverflowDefaultBinArrayBitmap(binArrayIndex),
+      false
+    );
+    if (overflowDefaultBinArrayBitmap && !binArrayOrBitmapInitTracking.has(bitmapPubkey.toBase58())) {
+      const initBitmapIx = await dlmm.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
+        binArrayBitmapExtension: bitmapPubkey,
+        lbPair: dlmm.pubkey,
+        funder: payer
+      }).instruction();
+      initBitmapIxs.push(initBitmapIx);
+      binArrayOrBitmapInitTracking.add(bitmapPubkey.toBase58());
+    }
+    const binArrayPubkeys = binArrayIndexes.map(
+      (index) => deriveBinArray(dlmm.pubkey, index, dlmm.program.programId)[0]
+    );
+    for (const [idx, binArrayPubkey] of binArrayPubkeys.entries()) {
+      if (!binArrayOrBitmapInitTracking.has(binArrayPubkey.toBase58())) {
+        const initBinArrayIx = await dlmm.program.methods.initializeBinArray(binArrayIndexes[idx]).accountsPartial({
+          binArray: binArrayPubkey,
+          funder: payer,
+          lbPair: dlmm.pubkey
+        }).instruction();
+        binArrayOrBitmapInitTracking.add(binArrayPubkey.toBase58());
+        initBinArrayIxs.push(initBinArrayIx);
+        calculatedAddLiquidityCU += DEFAULT_INIT_BIN_ARRAY_CU;
+      }
+    }
+    const minDeltaId = new (0, _anchor.BN)(chunkMinBinId - dlmm.lbPair.activeId);
+    const maxDeltaId = new (0, _anchor.BN)(chunkMaxBinId - dlmm.lbPair.activeId);
+    const { bitFlag, ...baseAndDelta } = buildBitFlagAndNegateStrategyParameters(
+      liquidityStrategyParameters.x0,
+      liquidityStrategyParameters.y0,
+      liquidityStrategyParameters.deltaX,
+      liquidityStrategyParameters.deltaY
+    );
+    const { deltaX, deltaY, x0, y0 } = resetUninvolvedLiquidityParams(
+      minDeltaId,
+      maxDeltaId,
+      strategy.singleSidedX,
+      {
+        ...baseAndDelta
+      }
+    );
+    const addParam = {
+      minDeltaId: minDeltaId.toNumber(),
+      maxDeltaId: maxDeltaId.toNumber(),
+      x0,
+      y0,
+      deltaX,
+      deltaY,
+      bitFlag,
+      favorXInActiveId: strategy.singleSidedX,
+      padding: Array(36).fill(0)
+    };
+    const { totalXAmount, totalYAmount } = toAmountIntoBins(
+      new (0, _anchor.BN)(dlmm.lbPair.activeId),
+      minDeltaId,
+      maxDeltaId,
+      deltaX,
+      deltaY,
+      x0,
+      y0,
+      new (0, _anchor.BN)(dlmm.lbPair.binStep),
+      strategy.singleSidedX
+    ).reduce(
+      (acc, bin) => {
+        return {
+          totalXAmount: acc.totalXAmount.add(bin.amountX),
+          totalYAmount: acc.totalYAmount.add(bin.amountY)
+        };
+      },
+      {
+        totalXAmount: new (0, _anchor.BN)(0),
+        totalYAmount: new (0, _anchor.BN)(0)
+      }
+    );
+    const totalXAmountIncludeTransferFee = calculateTransferFeeIncludedAmount(
+      totalXAmount,
+      dlmm.tokenX.mint,
+      dlmm.clock.epoch.toNumber()
+    ).amount;
+    const totalYAmountIncludeTransferFee = calculateTransferFeeIncludedAmount(
+      totalYAmount,
+      dlmm.tokenY.mint,
+      dlmm.clock.epoch.toNumber()
+    ).amount;
+    const maxDepositXAmount = getSlippageMaxAmount(
+      totalXAmountIncludeTransferFee,
+      slippagePercentage
+    );
+    const maxDepositYAmount = getSlippageMaxAmount(
+      totalYAmountIncludeTransferFee,
+      slippagePercentage
+    );
+    const rebalanceIx = await dlmm.program.methods.rebalanceLiquidity(
+      {
+        activeId: dlmm.lbPair.activeId,
+        maxActiveBinSlippage,
+        shouldClaimFee: false,
+        shouldClaimReward: false,
+        minWithdrawXAmount: new (0, _anchor.BN)(0),
+        minWithdrawYAmount: new (0, _anchor.BN)(0),
+        maxDepositXAmount,
+        maxDepositYAmount,
+        removes: [],
+        adds: [addParam],
+        padding: Array(32).fill(0)
+      },
+      {
+        slices
+      }
+    ).accountsPartial({
+      binArrayBitmapExtension: initBitmapIxs.length > 0 ? bitmapPubkey : dlmm.program.programId,
+      lbPair: dlmm.pubkey,
+      position,
+      owner,
+      tokenXMint: dlmm.lbPair.tokenXMint,
+      tokenYMint: dlmm.lbPair.tokenYMint,
+      userTokenX,
+      userTokenY,
+      tokenXProgram: dlmm.tokenX.owner,
+      tokenYProgram: dlmm.tokenY.owner,
+      rentPayer: payer
+    }).remainingAccounts([
+      ...transferHookAccounts,
+      ...binArrayPubkeys.map((baPubkey) => ({
+        pubkey: baPubkey,
+        isWritable: true,
+        isSigner: false
+      })),
+      derivePlaceHolderAccountMeta(dlmm.program.programId)
+    ]).instruction();
+    calculatedAddLiquidityCU += DEFAULT_ADD_LIQUIDITY_CU;
+    const addLiquidityIxs = [];
+    addLiquidityIxs.push(
+      ...initBitmapIxs,
+      ...initBinArrayIxs,
+      createUserTokenXIx,
+      createUserTokenYIx
+    );
+    if (dlmm.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && !totalXAmount.isZero()) {
+      const wrapSOLIx = wrapSOLInstruction(
+        owner,
+        userTokenX,
+        BigInt(totalXAmount.toString())
+      );
+      addLiquidityIxs.push(...wrapSOLIx);
+    }
+    if (dlmm.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && !totalYAmount.isZero()) {
+      const wrapSOLIx = wrapSOLInstruction(
+        owner,
+        userTokenY,
+        BigInt(totalYAmount.toString())
+      );
+      addLiquidityIxs.push(...wrapSOLIx);
+    }
+    addLiquidityIxs.push(rebalanceIx);
+    if (simulateCU) {
+      const cuIx = await getEstimatedComputeUnitIxWithBuffer(
+        dlmm.program.provider.connection,
+        addLiquidityIxs,
+        payer
+      );
+      addLiquidityIxs.unshift(cuIx);
+    } else {
+      addLiquidityIxs.unshift(
+        _web3js.ComputeBudgetProgram.setComputeUnitLimit({
+          units: Math.min(calculatedAddLiquidityCU, MAX_CU)
+        })
+      );
+    }
+    chunkedAddLiquidityIx.push(addLiquidityIxs);
   }
-  return extendedPosition;
+  return chunkedAddLiquidityIx;
 }
 
+// src/dlmm/helpers/accountFilters.ts
+var _bytes = require('@coral-xyz/anchor/dist/cjs/utils/bytes');
+var presetParameter2BinStepFilter = (binStep) => {
+  return {
+    memcmp: {
+      bytes: _bytes.bs58.encode(binStep.toArrayLike(Buffer, "le", 2)),
+      offset: 8
+    }
+  };
+};
+var presetParameter2BaseFactorFilter = (baseFactor) => {
+  return {
+    memcmp: {
+      bytes: _bytes.bs58.encode(baseFactor.toArrayLike(Buffer, "le", 2)),
+      offset: 8 + 2
+    }
+  };
+};
+var presetParameter2BaseFeePowerFactor = (baseFeePowerFactor) => {
+  return {
+    memcmp: {
+      bytes: _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: _bytes.bs58.encode(lbPair.toBuffer()),
+      offset: 8
+    }
+  };
+};
+var positionV2Filter = () => {
+  return {
+    memcmp: {
+      bytes: _bytes.bs58.encode(Buffer.from(getAccountDiscriminator("positionV2"))),
+      offset: 0
+    }
+  };
+};
+
 // src/dlmm/helpers/rebalance/strategy/balanced.ts
 
 
@@ -15487,6 +15755,137 @@ var DLMM = class {
       version: position.version()
     };
   }
+  /**
+   * Creates multiple positions and adds liquidity by strategy without chainsaw issues.
+   * @param positionKeypairGenerator A function that generates a specified number of keypairs.
+   * @param totalXAmount The total amount of token X to be added.
+   * @param totalYAmount The total amount of token Y to be added.
+   * @param strategy The strategy for adding liquidity.
+   * @param owner The owner of the position.
+   * @param payer The payer of the transaction.
+   * @param slippagePercentage The slippage percentage for adding liquidity.
+   * @returns An object with two properties: `initPositionIxs` and `addLiquidityIxs`.
+   */
+  async initializeMultiplePositionAndAddLiquidityByStrategy(positionKeypairGenerator, totalXAmount, totalYAmount, strategy, owner, payer, slippagePercentage) {
+    const maxActiveBinSlippage = getAndCapMaxActiveBinSlippage(
+      slippagePercentage,
+      this.lbPair.binStep,
+      MAX_ACTIVE_BIN_SLIPPAGE
+    );
+    const { minBinId, maxBinId } = strategy;
+    const binCount = getBinCount(minBinId, maxBinId);
+    const positionCount = getPositionCountByBinCount(binCount);
+    const positionKeypairs = await positionKeypairGenerator(positionCount);
+    const liquidityStrategyParameters = buildLiquidityStrategyParameters(
+      totalXAmount,
+      totalYAmount,
+      new (0, _anchor.BN)(minBinId - this.lbPair.activeId),
+      new (0, _anchor.BN)(maxBinId - this.lbPair.activeId),
+      new (0, _anchor.BN)(this.lbPair.binStep),
+      strategy.singleSidedX,
+      new (0, _anchor.BN)(this.lbPair.activeId),
+      getLiquidityStrategyParameterBuilder(strategy.strategyType)
+    );
+    const instructionsByPositions = [];
+    let startBinId = minBinId;
+    for (const position of positionKeypairs) {
+      const endBinId = Math.min(
+        startBinId + MAX_BINS_PER_POSITION.toNumber() - 1,
+        maxBinId
+      );
+      const binCount2 = getBinCount(startBinId, endBinId);
+      const positionWidth = Math.min(
+        binCount2,
+        DEFAULT_BIN_PER_POSITION.toNumber()
+      );
+      const initPositionIx = await this.program.methods.initializePosition(startBinId, positionWidth).accountsPartial({
+        position: position.publicKey,
+        lbPair: this.pubkey,
+        owner,
+        payer
+      }).instruction();
+      const chunkedAddLiquidityIx = await chunkDepositWithRebalanceEndpoint(
+        this,
+        strategy,
+        slippagePercentage,
+        maxActiveBinSlippage,
+        position.publicKey,
+        startBinId,
+        endBinId,
+        liquidityStrategyParameters,
+        owner,
+        payer,
+        false
+      );
+      instructionsByPositions.push({
+        positionKeypair: position,
+        initializePositionIx: initPositionIx,
+        addLiquidityIxs: chunkedAddLiquidityIx
+      });
+      startBinId = endBinId + 1;
+    }
+    return {
+      instructionsByPositions
+    };
+  }
+  /**
+   * Adds liquidity to an existing position using a specified strategy, allowing for chunkable transactions.
+   * If adding liquidity to bin out of position range, it will automatically expand. The limitation is 70 bins.
+   *
+   * @param {TInitializePositionAndAddLiquidityParamsByStrategy} params - The parameters required for adding liquidity.
+   * @param {PublicKey} params.positionPubKey - The public key of the position to which liquidity is being added.
+   * @param {BN} params.totalXAmount - The total amount of token X to be added as liquidity.
+   * @param {BN} params.totalYAmount - The total amount of token Y to be added as liquidity.
+   * @param {StrategyParameters} params.strategy - The strategy parameters for adding liquidity.
+   * @param {PublicKey} params.user - The public key of the user adding liquidity.
+   * @param {number} params.slippage - The slippage percentage allowed for the transaction.
+   *
+   * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions for adding liquidity.
+   */
+  async addLiquidityByStrategyChunkable({
+    positionPubKey,
+    totalXAmount,
+    totalYAmount,
+    strategy,
+    user,
+    slippage
+  }) {
+    const maxActiveBinSlippage = getAndCapMaxActiveBinSlippage(
+      slippage,
+      this.lbPair.binStep,
+      MAX_ACTIVE_BIN_SLIPPAGE
+    );
+    const { minBinId, maxBinId } = strategy;
+    const liquidityStrategyParameters = buildLiquidityStrategyParameters(
+      totalXAmount,
+      totalYAmount,
+      new (0, _anchor.BN)(minBinId - this.lbPair.activeId),
+      new (0, _anchor.BN)(maxBinId - this.lbPair.activeId),
+      new (0, _anchor.BN)(this.lbPair.binStep),
+      strategy.singleSidedX,
+      new (0, _anchor.BN)(this.lbPair.activeId),
+      getLiquidityStrategyParameterBuilder(strategy.strategyType)
+    );
+    const chunkedAddLiquidityIx = await chunkDepositWithRebalanceEndpoint(
+      this,
+      strategy,
+      slippage,
+      maxActiveBinSlippage,
+      positionPubKey,
+      minBinId,
+      maxBinId,
+      liquidityStrategyParameters,
+      user,
+      user,
+      true
+    );
+    const latestBlockhashInfo = await this.program.provider.connection.getLatestBlockhash();
+    return chunkedAddLiquidityIx.map((ixs) => {
+      return new (0, _web3js.Transaction)({
+        ...latestBlockhashInfo
+      }).add(...ixs);
+    });
+  }
   /**
    * The function `initializePositionAndAddLiquidityByStrategy` function is used to initializes a position and adds liquidity
    * @param {TInitializePositionAndAddLiquidityParamsByStrategy}
@@ -15847,7 +16246,7 @@ var DLMM = class {
     return transactions;
   }
   /**
-   * The `addLiquidityByStrategy` function is used to add liquidity to existing position. It will chunk the bin range into multiple add liquidity transactions if it exceed max size.
+   * The `addLiquidityByStrategy` function is used to add liquidity to existing position
    * @param {TInitializePositionAndAddLiquidityParamsByStrategy}
    *    - `positionPubKey`: The public key of the position account. (usually use `new Keypair()`)
    *    - `totalXAmount`: The total amount of token X to be added to the liquidity pool.
@@ -15855,7 +16254,8 @@ var DLMM = class {
    *    - `strategy`: The strategy parameters to be used for the liquidity pool (Can use `calculateStrategyParameter` to calculate).
    *    - `user`: The public key of the user account.
    *    - `slippage`: The slippage percentage to be used for the liquidity pool.
-   * @returns {Promise<Transaction[]>} The function `addLiquidityByStrategy` returns a `Promise` that resolves to an array of transactions
+   * @returns {Promise<Transaction>} The function `addLiquidityByWeight` returns a `Promise` that resolves to either a single
+   * `Transaction` object
    */
   async addLiquidityByStrategy({
     positionPubKey,
@@ -15867,179 +16267,117 @@ var DLMM = class {
   }) {
     const { maxBinId, minBinId } = strategy;
     const maxActiveBinSlippage = slippage ? Math.ceil(slippage / (this.lbPair.binStep / 100)) : MAX_ACTIVE_BIN_SLIPPAGE;
-    const activeBin = await this.getActiveBin();
-    const liquidityDistribution = toAmountsBothSideByStrategy(
-      activeBin.binId,
-      this.lbPair.binStep,
-      minBinId,
-      maxBinId,
-      totalXAmount,
-      totalYAmount,
-      activeBin.xAmount,
-      activeBin.yAmount,
-      strategy.strategyType,
-      this.tokenX.mint,
-      this.tokenY.mint,
-      this.clock
-    );
-    const chunkedBinRange = chunkBinRange(minBinId, maxBinId);
-    const userTokenX = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-      this.lbPair.tokenXMint,
-      user,
-      true,
-      this.tokenX.owner
-    );
-    const userTokenY = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-      this.lbPair.tokenYMint,
-      user,
-      true,
-      this.tokenY.owner
+    const preInstructions = [];
+    const minBinArrayIndex = binIdToBinArrayIndex(new (0, _anchor.BN)(minBinId));
+    const maxBinArrayIndex = binIdToBinArrayIndex(new (0, _anchor.BN)(maxBinId));
+    const useExtension = isOverflowDefaultBinArrayBitmap(minBinArrayIndex) || isOverflowDefaultBinArrayBitmap(maxBinArrayIndex);
+    const binArrayBitmapExtension = useExtension ? deriveBinArrayBitmapExtension(this.pubkey, this.program.programId)[0] : null;
+    const strategyParameters = toStrategyParameters(strategy);
+    const binArrayIndexes = getBinArrayIndexesCoverage(
+      new (0, _anchor.BN)(minBinId),
+      new (0, _anchor.BN)(maxBinId)
     );
-    const createUserTokenXIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-      user,
-      userTokenX,
-      user,
-      this.lbPair.tokenXMint,
-      this.tokenX.owner
+    const binArrayAccountsMeta = getBinArrayAccountMetasCoverage(
+      new (0, _anchor.BN)(minBinId),
+      new (0, _anchor.BN)(maxBinId),
+      this.pubkey,
+      this.program.programId
     );
-    const createUserTokenYIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-      user,
-      userTokenY,
-      user,
-      this.lbPair.tokenYMint,
-      this.tokenY.owner
+    const createBinArrayIxs = await this.createBinArraysIfNeeded(
+      binArrayIndexes,
+      user
     );
-    const { slices, accounts: transferHookAccounts } = this.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
-    const groupedInstructions = [];
-    for (const {
-      lowerBinId: chunkedMinBinId,
-      upperBinId: chunkedMaxBinId
-    } of chunkedBinRange) {
-      const preInstructions = [];
-      const minBinArrayIndex = binIdToBinArrayIndex(new (0, _anchor.BN)(chunkedMinBinId));
-      const maxBinArrayIndex = binIdToBinArrayIndex(new (0, _anchor.BN)(chunkedMaxBinId));
-      const useExtension = isOverflowDefaultBinArrayBitmap(minBinArrayIndex) || isOverflowDefaultBinArrayBitmap(maxBinArrayIndex);
-      const binArrayBitmapExtension = useExtension ? deriveBinArrayBitmapExtension(this.pubkey, this.program.programId)[0] : null;
-      const chunkedStrategyParameter = {
-        minBinId: chunkedMinBinId,
-        maxBinId: chunkedMaxBinId,
-        strategyType: strategy.strategyType,
-        singleSidedX: strategy.singleSidedX
-      };
-      const strategyParameters = toStrategyParameters(chunkedStrategyParameter);
-      const binArrayIndexes = getBinArrayIndexesCoverage(
-        new (0, _anchor.BN)(chunkedMinBinId),
-        new (0, _anchor.BN)(chunkedMaxBinId)
-      );
-      const binArrayAccountsMeta = getBinArrayAccountMetasCoverage(
-        new (0, _anchor.BN)(chunkedMinBinId),
-        new (0, _anchor.BN)(chunkedMaxBinId),
-        this.pubkey,
-        this.program.programId
-      );
-      const createBinArrayIxs = await this.createBinArraysIfNeeded(
-        binArrayIndexes,
-        user
-      );
-      preInstructions.push(...createBinArrayIxs);
-      preInstructions.push(createUserTokenXIx);
-      preInstructions.push(createUserTokenYIx);
-      if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && !totalXAmount.isZero()) {
-        const wrapSOLIx = wrapSOLInstruction(
-          user,
-          userTokenX,
-          BigInt(totalXAmount.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
-      }
-      if (this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && !totalYAmount.isZero()) {
-        const wrapSOLIx = wrapSOLInstruction(
-          user,
-          userTokenY,
-          BigInt(totalYAmount.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
-      }
-      const postInstructions = [];
-      if ([
-        this.tokenX.publicKey.toBase58(),
-        this.tokenY.publicKey.toBase58()
-      ].includes(_spltoken.NATIVE_MINT.toBase58())) {
-        const closeWrappedSOLIx = await unwrapSOLInstruction(user);
-        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
-      }
-      let chunkedTotalAmountX = new (0, _anchor.BN)(0);
-      let chunkedTotalAmountY = new (0, _anchor.BN)(0);
-      for (const { binId, amountX, amountY } of liquidityDistribution) {
-        if (binId >= chunkedMinBinId && binId <= chunkedMaxBinId) {
-          chunkedTotalAmountX = chunkedTotalAmountX.add(amountX);
-          chunkedTotalAmountY = chunkedTotalAmountY.add(amountY);
-        }
-      }
-      chunkedTotalAmountX = calculateTransferFeeIncludedAmount(
-        chunkedTotalAmountX,
-        this.tokenX.mint,
-        this.clock.epoch.toNumber()
-      ).amount;
-      chunkedTotalAmountY = calculateTransferFeeIncludedAmount(
-        chunkedTotalAmountY,
-        this.tokenY.mint,
-        this.clock.epoch.toNumber()
-      ).amount;
-      const liquidityParams = {
-        amountX: chunkedTotalAmountX,
-        amountY: chunkedTotalAmountY,
-        activeId: this.lbPair.activeId,
-        maxActiveBinSlippage,
-        strategyParameters
-      };
-      const addLiquidityAccounts = {
-        position: positionPubKey,
-        lbPair: this.pubkey,
+    preInstructions.push(...createBinArrayIxs);
+    const [
+      { ataPubKey: userTokenX, ix: createPayerTokenXIx },
+      { ataPubKey: userTokenY, ix: createPayerTokenYIx }
+    ] = await Promise.all([
+      getOrCreateATAInstruction(
+        this.program.provider.connection,
+        this.tokenX.publicKey,
+        user,
+        this.tokenX.owner
+      ),
+      getOrCreateATAInstruction(
+        this.program.provider.connection,
+        this.tokenY.publicKey,
+        user,
+        this.tokenY.owner
+      )
+    ]);
+    createPayerTokenXIx && preInstructions.push(createPayerTokenXIx);
+    createPayerTokenYIx && preInstructions.push(createPayerTokenYIx);
+    if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && !totalXAmount.isZero()) {
+      const wrapSOLIx = wrapSOLInstruction(
+        user,
         userTokenX,
+        BigInt(totalXAmount.toString())
+      );
+      preInstructions.push(...wrapSOLIx);
+    }
+    if (this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && !totalYAmount.isZero()) {
+      const wrapSOLIx = wrapSOLInstruction(
+        user,
         userTokenY,
-        reserveX: this.lbPair.reserveX,
-        reserveY: this.lbPair.reserveY,
-        tokenXMint: this.lbPair.tokenXMint,
-        tokenYMint: this.lbPair.tokenYMint,
-        binArrayBitmapExtension,
-        sender: user,
-        tokenXProgram: this.tokenX.owner,
-        tokenYProgram: this.tokenY.owner,
-        memoProgram: MEMO_PROGRAM_ID
-      };
-      const programMethod = this.program.methods.addLiquidityByStrategy2(
-        liquidityParams,
-        {
-          slices
-        }
+        BigInt(totalYAmount.toString())
       );
-      const addLiquidityIx = await programMethod.accountsPartial(addLiquidityAccounts).remainingAccounts(transferHookAccounts).remainingAccounts(binArrayAccountsMeta).instruction();
-      const instructions = [
-        ...preInstructions,
-        addLiquidityIx,
-        ...postInstructions
-      ];
-      groupedInstructions.push(instructions);
+      preInstructions.push(...wrapSOLIx);
     }
-    const groupedInstructionsWithCUIx = await Promise.all(
-      groupedInstructions.map(async (ixs) => {
-        const setCUIx = await getEstimatedComputeUnitIxWithBuffer(
-          this.program.provider.connection,
-          ixs,
-          user
-        );
-        return [setCUIx, ...ixs];
-      })
+    const postInstructions = [];
+    if ([
+      this.tokenX.publicKey.toBase58(),
+      this.tokenY.publicKey.toBase58()
+    ].includes(_spltoken.NATIVE_MINT.toBase58())) {
+      const closeWrappedSOLIx = await unwrapSOLInstruction(user);
+      closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+    }
+    const liquidityParams = {
+      amountX: totalXAmount,
+      amountY: totalYAmount,
+      activeId: this.lbPair.activeId,
+      maxActiveBinSlippage,
+      strategyParameters
+    };
+    const addLiquidityAccounts = {
+      position: positionPubKey,
+      lbPair: this.pubkey,
+      userTokenX,
+      userTokenY,
+      reserveX: this.lbPair.reserveX,
+      reserveY: this.lbPair.reserveY,
+      tokenXMint: this.lbPair.tokenXMint,
+      tokenYMint: this.lbPair.tokenYMint,
+      binArrayBitmapExtension,
+      sender: user,
+      tokenXProgram: this.tokenX.owner,
+      tokenYProgram: this.tokenY.owner,
+      memoProgram: MEMO_PROGRAM_ID
+    };
+    const { slices, accounts: transferHookAccounts } = this.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
+    const programMethod = this.program.methods.addLiquidityByStrategy2(
+      liquidityParams,
+      {
+        slices
+      }
+    );
+    const addLiquidityIx = await programMethod.accounts(addLiquidityAccounts).remainingAccounts(transferHookAccounts).remainingAccounts(binArrayAccountsMeta).instruction();
+    const instructions = [
+      ...preInstructions,
+      addLiquidityIx,
+      ...postInstructions
+    ];
+    const setCUIx = await getEstimatedComputeUnitIxWithBuffer(
+      this.program.provider.connection,
+      instructions,
+      user
     );
+    instructions.unshift(setCUIx);
     const { blockhash, lastValidBlockHeight } = await this.program.provider.connection.getLatestBlockhash("confirmed");
-    return groupedInstructionsWithCUIx.map((ixs) => {
-      return new (0, _web3js.Transaction)({
-        blockhash,
-        lastValidBlockHeight,
-        feePayer: user
-      }).add(...ixs);
-    });
+    return new (0, _web3js.Transaction)({
+      blockhash,
+      lastValidBlockHeight,
+      feePayer: user
+    }).add(...instructions);
   }
   /**
    * @deprecated Use `addLiquidityByStrategy` instead which support both token and token2022.
@@ -18565,302 +18903,229 @@ var DLMM = class {
     const { lbPair, shouldClaimFee, shouldClaimReward, owner, address } = rebalancePosition;
     const { depositParams, withdrawParams } = simulationResult;
     const activeId = new (0, _anchor.BN)(lbPair.activeId);
-    let minBinId = Number.POSITIVE_INFINITY;
-    let maxBinId = Number.NEGATIVE_INFINITY;
-    for (const param of depositParams) {
-      const min = activeId.toNumber() + param.minDeltaId;
-      const max = activeId.toNumber() + param.maxDeltaId;
-      if (min < minBinId)
-        minBinId = min;
-      if (max > maxBinId)
-        maxBinId = max;
-    }
-    for (const param of withdrawParams) {
-      if (param.minBinId !== null && param.minBinId < minBinId)
-        minBinId = param.minBinId;
-      if (param.maxBinId !== null && param.maxBinId > maxBinId)
-        maxBinId = param.maxBinId;
-    }
-    if (!Number.isFinite(minBinId) || !Number.isFinite(maxBinId)) {
-      throw new Error("Unable to determine min/max binId for chunking");
-    }
-    const binChunks = chunkBinRange(minBinId, maxBinId);
-    function splitDepositParamsForChunk(params, chunk, activeId2) {
-      const res = [];
-      for (const param of params) {
-        const absMin = activeId2.toNumber() + param.minDeltaId;
-        const absMax = activeId2.toNumber() + param.maxDeltaId;
-        if (absMax < chunk.lowerBinId || absMin > chunk.upperBinId)
-          continue;
-        const newMin = Math.max(absMin, chunk.lowerBinId);
-        const newMax = Math.min(absMax, chunk.upperBinId);
-        res.push({
-          ...param,
-          minDeltaId: newMin - activeId2.toNumber(),
-          maxDeltaId: newMax - activeId2.toNumber()
-        });
-      }
-      return res;
-    }
-    function splitWithdrawParamsForChunk(params, chunk) {
-      const res = [];
-      for (const param of params) {
-        const absMin = param.minBinId !== null ? param.minBinId : activeId.toNumber();
-        const absMax = param.maxBinId !== null ? param.maxBinId : activeId.toNumber();
-        if (absMax < chunk.lowerBinId || absMin > chunk.upperBinId)
-          continue;
-        const newMin = Math.max(absMin, chunk.lowerBinId);
-        const newMax = Math.min(absMax, chunk.upperBinId);
-        res.push({
-          ...param,
-          minBinId: newMin,
-          maxBinId: newMax
-        });
-      }
-      return res;
-    }
-    const allInstructions = [];
-    for (const chunk of binChunks) {
-      const chunkedDepositParams = splitDepositParamsForChunk(
-        depositParams,
-        chunk,
-        activeId
-      );
-      const chunkedWithdrawParams = splitWithdrawParamsForChunk(
-        withdrawParams,
-        chunk
-      );
-      if (chunkedDepositParams.length === 0 && chunkedWithdrawParams.length === 0)
-        continue;
-      const { slices, accounts: transferHookAccounts } = this.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
-      const preInstructions = [];
-      const harvestRewardRemainingAccountMetas = [];
-      if (shouldClaimReward) {
-        for (const [idx, reward] of this.lbPair.rewardInfos.entries()) {
-          if (!reward.mint.equals(_web3js.PublicKey.default)) {
-            const rewardTokenInfo = this.rewards[idx];
-            slices.push({
-              accountsType: {
-                transferHookMultiReward: {
-                  0: idx
-                }
-              },
-              length: rewardTokenInfo.transferHookAccountMetas.length
-            });
-            transferHookAccounts.push(
-              ...rewardTokenInfo.transferHookAccountMetas
-            );
-            const userTokenRewardAddress = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-              reward.mint,
+    const { slices, accounts: transferHookAccounts } = this.getPotentialToken2022IxDataAndAccounts(0 /* Liquidity */);
+    const preInstructions = [];
+    const harvestRewardRemainingAccountMetas = [];
+    if (shouldClaimReward) {
+      for (const [idx, reward] of this.lbPair.rewardInfos.entries()) {
+        if (!reward.mint.equals(_web3js.PublicKey.default)) {
+          const rewardTokenInfo = this.rewards[idx];
+          slices.push({
+            accountsType: {
+              transferHookMultiReward: {
+                0: idx
+              }
+            },
+            length: rewardTokenInfo.transferHookAccountMetas.length
+          });
+          transferHookAccounts.push(
+            ...rewardTokenInfo.transferHookAccountMetas
+          );
+          const userTokenRewardAddress = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
+            reward.mint,
+            owner,
+            true,
+            rewardTokenInfo.owner
+          );
+          preInstructions.push(
+            _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
               owner,
-              true,
+              userTokenRewardAddress,
+              owner,
+              reward.mint,
               rewardTokenInfo.owner
-            );
-            preInstructions.push(
-              _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-                owner,
-                userTokenRewardAddress,
-                owner,
-                reward.mint,
-                rewardTokenInfo.owner
-              )
-            );
-            const rewardVault = {
-              pubkey: reward.vault,
-              isSigner: false,
-              isWritable: true
-            };
-            const userTokenReward = {
-              pubkey: userTokenRewardAddress,
-              isSigner: false,
-              isWritable: true
-            };
-            const rewardMint = {
-              pubkey: reward.mint,
-              isSigner: false,
-              isWritable: false
-            };
-            const rewardTokenProgram = {
-              pubkey: rewardTokenInfo.owner,
-              isSigner: false,
-              isWritable: false
-            };
-            harvestRewardRemainingAccountMetas.push(
-              rewardVault,
-              userTokenReward,
-              rewardMint,
-              rewardTokenProgram
-            );
-          }
+            )
+          );
+          const rewardVault = {
+            pubkey: reward.vault,
+            isSigner: false,
+            isWritable: true
+          };
+          const userTokenReward = {
+            pubkey: userTokenRewardAddress,
+            isSigner: false,
+            isWritable: true
+          };
+          const rewardMint = {
+            pubkey: reward.mint,
+            isSigner: false,
+            isWritable: false
+          };
+          const rewardTokenProgram = {
+            pubkey: rewardTokenInfo.owner,
+            isSigner: false,
+            isWritable: false
+          };
+          harvestRewardRemainingAccountMetas.push(
+            rewardVault,
+            userTokenReward,
+            rewardMint,
+            rewardTokenProgram
+          );
         }
       }
-      const initBinArrayInstructions = [];
-      const { binArrayBitmap, binArrayIndexes } = getRebalanceBinArrayIndexesAndBitmapCoverage(
-        chunkedDepositParams,
-        chunkedWithdrawParams,
-        activeId.toNumber(),
+    }
+    const initBinArrayInstructions = [];
+    const { binArrayBitmap, binArrayIndexes } = getRebalanceBinArrayIndexesAndBitmapCoverage(
+      depositParams,
+      withdrawParams,
+      activeId.toNumber(),
+      this.pubkey,
+      this.program.programId
+    );
+    const binArrayPublicKeys = binArrayIndexes.map((index) => {
+      const [binArrayPubkey] = deriveBinArray(
         this.pubkey,
+        index,
         this.program.programId
       );
-      const binArrayPublicKeys = binArrayIndexes.map((index) => {
-        const [binArrayPubkey] = deriveBinArray(
-          this.pubkey,
-          index,
-          this.program.programId
-        );
-        return binArrayPubkey;
-      });
-      const binArrayAccounts = await chunkedGetMultipleAccountInfos(
-        this.program.provider.connection,
-        binArrayPublicKeys
-      );
-      for (let i = 0; i < binArrayAccounts.length; i++) {
-        const binArrayAccount = binArrayAccounts[i];
-        if (!binArrayAccount) {
-          const binArrayPubkey = binArrayPublicKeys[i];
-          const binArrayIndex = binArrayIndexes[i];
-          const initBinArrayIx = await this.program.methods.initializeBinArray(binArrayIndex).accountsPartial({
-            binArray: binArrayPubkey,
-            funder: owner,
-            lbPair: this.pubkey
-          }).instruction();
-          initBinArrayInstructions.push(initBinArrayIx);
-        }
-      }
-      if (!binArrayBitmap.equals(_web3js.PublicKey.default)) {
-        const bitmapAccount = await this.program.provider.connection.getAccountInfo(binArrayBitmap);
-        if (!bitmapAccount) {
-          const initBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
-            binArrayBitmapExtension: binArrayBitmap,
-            funder: owner,
-            lbPair: this.pubkey
-          }).preInstructions([
-            _web3js.ComputeBudgetProgram.setComputeUnitLimit({
-              units: DEFAULT_INIT_BIN_ARRAY_CU
-            })
-          ]).instruction();
-          preInstructions.push(initBitmapExtensionIx);
-        }
-      }
-      const [
-        { ataPubKey: userTokenX, ix: createUserTokenXIx },
-        { ataPubKey: userTokenY, ix: createUserTokenYIx }
-      ] = await Promise.all([
-        getOrCreateATAInstruction(
-          this.program.provider.connection,
-          this.tokenX.publicKey,
-          owner,
-          this.tokenX.owner
-        ),
-        getOrCreateATAInstruction(
-          this.program.provider.connection,
-          this.tokenY.publicKey,
-          owner,
-          this.tokenY.owner
-        )
-      ]);
-      createUserTokenXIx && preInstructions.push(createUserTokenXIx);
-      createUserTokenYIx && preInstructions.push(createUserTokenYIx);
-      slippage = capSlippagePercentage(slippage);
-      const applySlippageMaxAmount = (amount, slippage2) => {
-        return slippage2 == 100 ? U64_MAX : amount.muln(100 + slippage2).divn(100);
-      };
-      const applySlippageMinAmount = (amount, slippage2) => {
-        return amount.muln(100 - slippage2).divn(100);
-      };
-      const maxDepositXAmount = applySlippageMaxAmount(
-        simulationResult.actualAmountXDeposited,
-        slippage
-      );
-      const maxDepositYAmount = applySlippageMaxAmount(
-        simulationResult.actualAmountYDeposited,
-        slippage
-      );
-      const minWithdrawXAmount = applySlippageMinAmount(
-        simulationResult.actualAmountXWithdrawn,
-        slippage
-      );
-      const minWithdrawYAmount = applySlippageMinAmount(
-        simulationResult.actualAmountYWithdrawn,
-        slippage
-      );
-      const postInstructions = [];
-      if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountXDeposited.gtn(0)) {
-        const wrapSOLIx = wrapSOLInstruction(
-          owner,
-          userTokenX,
-          BigInt(simulationResult.actualAmountXDeposited.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
-      }
-      if (this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountYDeposited.gtn(0)) {
-        const wrapSOLIx = wrapSOLInstruction(
-          owner,
-          userTokenY,
-          BigInt(simulationResult.actualAmountYDeposited.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
+      return binArrayPubkey;
+    });
+    const binArrayAccounts = await chunkedGetMultipleAccountInfos(
+      this.program.provider.connection,
+      binArrayPublicKeys
+    );
+    for (let i = 0; i < binArrayAccounts.length; i++) {
+      const binArrayAccount = binArrayAccounts[i];
+      if (!binArrayAccount) {
+        const binArrayPubkey = binArrayPublicKeys[i];
+        const binArrayIndex = binArrayIndexes[i];
+        const initBinArrayIx = await this.program.methods.initializeBinArray(binArrayIndex).accountsPartial({
+          binArray: binArrayPubkey,
+          funder: owner,
+          lbPair: this.pubkey
+        }).instruction();
+        initBinArrayInstructions.push(initBinArrayIx);
       }
-      if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) || this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT)) {
-        const closeWrappedSOLIx = await unwrapSOLInstruction(owner);
-        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+    }
+    if (!binArrayBitmap.equals(_web3js.PublicKey.default)) {
+      const bitmapAccount = await this.program.provider.connection.getAccountInfo(binArrayBitmap);
+      if (!bitmapAccount) {
+        const initBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
+          binArrayBitmapExtension: binArrayBitmap,
+          funder: owner,
+          lbPair: this.pubkey
+        }).preInstructions([
+          _web3js.ComputeBudgetProgram.setComputeUnitLimit({
+            units: DEFAULT_INIT_BIN_ARRAY_CU
+          })
+        ]).instruction();
+        preInstructions.push(initBitmapExtensionIx);
       }
-      const instruction = await this.program.methods.rebalanceLiquidity(
-        {
-          adds: chunkedDepositParams,
-          removes: chunkedWithdrawParams,
-          activeId: activeId.toNumber(),
-          shouldClaimFee,
-          shouldClaimReward,
-          maxActiveBinSlippage: maxActiveBinSlippage.toNumber(),
-          maxDepositXAmount,
-          maxDepositYAmount,
-          minWithdrawXAmount,
-          minWithdrawYAmount,
-          padding: Array(32).fill(0)
-        },
-        {
-          slices
-        }
-      ).accountsPartial({
-        lbPair: this.pubkey,
-        binArrayBitmapExtension: binArrayBitmap,
-        position: address,
+    }
+    const [
+      { ataPubKey: userTokenX, ix: createUserTokenXIx },
+      { ataPubKey: userTokenY, ix: createUserTokenYIx }
+    ] = await Promise.all([
+      getOrCreateATAInstruction(
+        this.program.provider.connection,
+        this.tokenX.publicKey,
+        owner,
+        this.tokenX.owner
+      ),
+      getOrCreateATAInstruction(
+        this.program.provider.connection,
+        this.tokenY.publicKey,
+        owner,
+        this.tokenY.owner
+      )
+    ]);
+    createUserTokenXIx && preInstructions.push(createUserTokenXIx);
+    createUserTokenYIx && preInstructions.push(createUserTokenYIx);
+    slippage = capSlippagePercentage(slippage);
+    const maxDepositXAmount = getSlippageMaxAmount(
+      simulationResult.actualAmountXDeposited,
+      slippage
+    );
+    const maxDepositYAmount = getSlippageMaxAmount(
+      simulationResult.actualAmountYDeposited,
+      slippage
+    );
+    const minWithdrawXAmount = getSlippageMinAmount(
+      simulationResult.actualAmountXWithdrawn,
+      slippage
+    );
+    const minWithdrawYAmount = getSlippageMinAmount(
+      simulationResult.actualAmountYWithdrawn,
+      slippage
+    );
+    const postInstructions = [];
+    if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountXDeposited.gtn(0)) {
+      const wrapSOLIx = wrapSOLInstruction(
         owner,
         userTokenX,
+        BigInt(simulationResult.actualAmountXDeposited.toString())
+      );
+      preInstructions.push(...wrapSOLIx);
+    }
+    if (this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountYDeposited.gtn(0)) {
+      const wrapSOLIx = wrapSOLInstruction(
+        owner,
         userTokenY,
-        reserveX: this.lbPair.reserveX,
-        reserveY: this.lbPair.reserveY,
-        tokenXMint: this.tokenX.publicKey,
-        tokenYMint: this.tokenY.publicKey,
-        tokenXProgram: this.tokenX.owner,
-        tokenYProgram: this.tokenY.owner,
-        memoProgram: MEMO_PROGRAM_ID,
-        rentPayer: _nullishCoalesce(rentPayer, () => ( owner))
-      }).remainingAccounts(transferHookAccounts).remainingAccounts(
-        binArrayPublicKeys.map((pubkey) => {
-          return {
-            pubkey,
-            isSigner: false,
-            isWritable: true
-          };
-        })
-      ).instruction();
-      const setCUIX = await getEstimatedComputeUnitIxWithBuffer(
-        this.program.provider.connection,
-        [instruction],
-        owner
+        BigInt(simulationResult.actualAmountYDeposited.toString())
       );
-      const rebalancePositionInstruction = [
-        setCUIX,
-        ...initBinArrayInstructions,
-        ...preInstructions,
-        instruction,
-        ...postInstructions
-      ];
-      allInstructions.push(rebalancePositionInstruction);
+      preInstructions.push(...wrapSOLIx);
     }
-    return allInstructions;
+    if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) || this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT)) {
+      const closeWrappedSOLIx = await unwrapSOLInstruction(owner);
+      closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+    }
+    const instruction = await this.program.methods.rebalanceLiquidity(
+      {
+        adds: depositParams,
+        removes: withdrawParams,
+        activeId: activeId.toNumber(),
+        shouldClaimFee,
+        shouldClaimReward,
+        maxActiveBinSlippage: maxActiveBinSlippage.toNumber(),
+        maxDepositXAmount,
+        maxDepositYAmount,
+        minWithdrawXAmount,
+        minWithdrawYAmount,
+        padding: Array(32).fill(0)
+      },
+      {
+        slices
+      }
+    ).accountsPartial({
+      lbPair: this.pubkey,
+      binArrayBitmapExtension: binArrayBitmap,
+      position: address,
+      owner,
+      userTokenX,
+      userTokenY,
+      reserveX: this.lbPair.reserveX,
+      reserveY: this.lbPair.reserveY,
+      tokenXMint: this.tokenX.publicKey,
+      tokenYMint: this.tokenY.publicKey,
+      tokenXProgram: this.tokenX.owner,
+      tokenYProgram: this.tokenY.owner,
+      memoProgram: MEMO_PROGRAM_ID,
+      rentPayer: _nullishCoalesce(rentPayer, () => ( owner))
+    }).remainingAccounts(transferHookAccounts).remainingAccounts(
+      binArrayPublicKeys.map((pubkey) => {
+        return {
+          pubkey,
+          isSigner: false,
+          isWritable: true
+        };
+      })
+    ).instruction();
+    const setCUIX = await getEstimatedComputeUnitIxWithBuffer(
+      this.program.provider.connection,
+      [instruction],
+      owner
+    );
+    const rebalancePositionInstruction = [
+      setCUIX,
+      ...preInstructions,
+      instruction,
+      ...postInstructions
+    ];
+    return {
+      initBinArrayInstructions,
+      rebalancePositionInstruction
+    };
   }
   /**
    * Create an extended empty position.
@@ -19636,5 +19901,14 @@ var src_default = DLMM;
 
 
 
-exports.ADMIN = ADMIN; exports.ActionType = ActionType; exports.ActivationType = ActivationType; exports.BASIS_POINT_MAX = BASIS_POINT_MAX; exports.BIN_ARRAY_BITMAP_FEE = BIN_ARRAY_BITMAP_FEE; exports.BIN_ARRAY_BITMAP_FEE_BN = BIN_ARRAY_BITMAP_FEE_BN; exports.BIN_ARRAY_BITMAP_SIZE = BIN_ARRAY_BITMAP_SIZE; exports.BIN_ARRAY_FEE = BIN_ARRAY_FEE; exports.BIN_ARRAY_FEE_BN = BIN_ARRAY_FEE_BN; exports.BinLiquidity = BinLiquidity; exports.BitmapType = BitmapType; exports.ClockLayout = ClockLayout; exports.DEFAULT_BIN_PER_POSITION = DEFAULT_BIN_PER_POSITION; exports.DLMMError = DLMMError; exports.DlmmSdkError = DlmmSdkError; exports.EXTENSION_BINARRAY_BITMAP_SIZE = EXTENSION_BINARRAY_BITMAP_SIZE; exports.FEE_PRECISION = FEE_PRECISION; exports.IDL = dlmm_default; exports.ILM_BASE = ILM_BASE; exports.LBCLMM_PROGRAM_IDS = LBCLMM_PROGRAM_IDS; exports.MAX_ACTIVE_BIN_SLIPPAGE = MAX_ACTIVE_BIN_SLIPPAGE; exports.MAX_BINS_PER_POSITION = MAX_BINS_PER_POSITION; exports.MAX_BIN_ARRAY_SIZE = MAX_BIN_ARRAY_SIZE; exports.MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX = MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX; exports.MAX_CLAIM_ALL_ALLOWED = MAX_CLAIM_ALL_ALLOWED; exports.MAX_EXTRA_BIN_ARRAYS = MAX_EXTRA_BIN_ARRAYS; exports.MAX_FEE_RATE = MAX_FEE_RATE; exports.MAX_RESIZE_LENGTH = MAX_RESIZE_LENGTH; exports.MEMO_PROGRAM_ID = MEMO_PROGRAM_ID; exports.Network = Network; exports.POOL_FEE = POOL_FEE; exports.POOL_FEE_BN = POOL_FEE_BN; exports.POSITION_BIN_DATA_SIZE = POSITION_BIN_DATA_SIZE; exports.POSITION_FEE = POSITION_FEE; exports.POSITION_FEE_BN = POSITION_FEE_BN; exports.POSITION_MAX_LENGTH = POSITION_MAX_LENGTH; exports.POSITION_MIN_SIZE = POSITION_MIN_SIZE; exports.PRECISION = PRECISION; exports.PairStatus = PairStatus; exports.PairType = PairType; exports.PositionVersion = PositionVersion; exports.RebalancePosition = RebalancePosition; exports.ResizeSide = ResizeSide; exports.SCALE = SCALE; exports.SCALE_OFFSET = SCALE_OFFSET; exports.SIMULATION_USER = SIMULATION_USER; exports.Strategy = Strategy; exports.StrategyType = StrategyType; exports.TOKEN_ACCOUNT_FEE = TOKEN_ACCOUNT_FEE; exports.TOKEN_ACCOUNT_FEE_BN = TOKEN_ACCOUNT_FEE_BN; exports.U64_MAX = U64_MAX; exports.autoFillXByStrategy = autoFillXByStrategy; exports.autoFillXByWeight = autoFillXByWeight; exports.autoFillYByStrategy = autoFillYByStrategy; exports.autoFillYByWeight = autoFillYByWeight; exports.binIdToBinArrayIndex = binIdToBinArrayIndex; exports.buildLiquidityStrategyParameters = buildLiquidityStrategyParameters; exports.calculateBidAskDistribution = calculateBidAskDistribution; exports.calculateNormalDistribution = calculateNormalDistribution; exports.calculateSpotDistribution = calculateSpotDistribution; exports.capSlippagePercentage = capSlippagePercentage; exports.chunkedFetchMultipleBinArrayBitmapExtensionAccount = chunkedFetchMultipleBinArrayBitmapExtensionAccount; exports.chunkedFetchMultiplePoolAccount = chunkedFetchMultiplePoolAccount; exports.chunkedGetMultipleAccountInfos = chunkedGetMultipleAccountInfos; exports.chunks = chunks; exports.computeFee = computeFee; exports.computeFeeFromAmount = computeFeeFromAmount; exports.computeProtocolFee = computeProtocolFee; exports.createProgram = createProgram; exports.decodeAccount = decodeAccount; exports.default = src_default; exports.deriveBinArray = deriveBinArray; exports.deriveBinArrayBitmapExtension = deriveBinArrayBitmapExtension; exports.deriveCustomizablePermissionlessLbPair = deriveCustomizablePermissionlessLbPair; exports.deriveEventAuthority = deriveEventAuthority; exports.deriveLbPair = deriveLbPair; exports.deriveLbPair2 = deriveLbPair2; exports.deriveLbPairWithPresetParamWithIndexKey = deriveLbPairWithPresetParamWithIndexKey; exports.deriveOracle = deriveOracle; exports.derivePermissionLbPair = derivePermissionLbPair; exports.derivePosition = derivePosition; exports.derivePresetParameter = derivePresetParameter; exports.derivePresetParameter2 = derivePresetParameter2; exports.derivePresetParameterWithIndex = derivePresetParameterWithIndex; exports.deriveReserve = deriveReserve; exports.deriveRewardVault = deriveRewardVault; exports.deriveTokenBadge = deriveTokenBadge; exports.enumerateBins = enumerateBins; exports.findNextBinArrayIndexWithLiquidity = findNextBinArrayIndexWithLiquidity; exports.findNextBinArrayWithLiquidity = findNextBinArrayWithLiquidity; exports.fromWeightDistributionToAmount = fromWeightDistributionToAmount; exports.fromWeightDistributionToAmountOneSide = fromWeightDistributionToAmountOneSide; exports.getAccountDiscriminator = getAccountDiscriminator; exports.getAmountInBinsAskSide = getAmountInBinsAskSide; exports.getAmountInBinsBidSide = getAmountInBinsBidSide; exports.getAutoFillAmountByRebalancedPosition = getAutoFillAmountByRebalancedPosition; exports.getBaseFee = getBaseFee; exports.getBinArrayLowerUpperBinId = getBinArrayLowerUpperBinId; exports.getBinArraysRequiredByPositionRange = getBinArraysRequiredByPositionRange; exports.getBinFromBinArray = getBinFromBinArray; exports.getBinIdIndexInBinArray = getBinIdIndexInBinArray; exports.getEstimatedComputeUnitIxWithBuffer = getEstimatedComputeUnitIxWithBuffer; exports.getEstimatedComputeUnitUsageWithBuffer = getEstimatedComputeUnitUsageWithBuffer; exports.getLiquidityStrategyParameterBuilder = getLiquidityStrategyParameterBuilder; exports.getOrCreateATAInstruction = getOrCreateATAInstruction; exports.getOutAmount = getOutAmount; exports.getPriceOfBinByBinId = getPriceOfBinByBinId; exports.getRebalanceBinArrayIndexesAndBitmapCoverage = getRebalanceBinArrayIndexesAndBitmapCoverage; exports.getTokenBalance = getTokenBalance; exports.getTokenDecimals = getTokenDecimals; exports.getTokenProgramId = getTokenProgramId; exports.getTokensMintFromPoolAddress = getTokensMintFromPoolAddress; exports.getTotalFee = getTotalFee; exports.getVariableFee = getVariableFee; exports.isBinIdWithinBinArray = isBinIdWithinBinArray; exports.isOverflowDefaultBinArrayBitmap = isOverflowDefaultBinArrayBitmap; exports.parseLogs = parseLogs; exports.range = range; exports.suggestBalancedXParametersFromY = suggestBalancedXParametersFromY; exports.suggestBalancedYParametersFromX = suggestBalancedYParametersFromX; exports.swapExactInQuoteAtBin = swapExactInQuoteAtBin; exports.swapExactOutQuoteAtBin = swapExactOutQuoteAtBin; exports.toAmountAskSide = toAmountAskSide; exports.toAmountBidSide = toAmountBidSide; exports.toAmountBothSide = toAmountBothSide; exports.toAmountIntoBins = toAmountIntoBins; exports.toAmountsBothSideByStrategy = toAmountsBothSideByStrategy; exports.toStrategyParameters = toStrategyParameters; exports.toWeightDistribution = toWeightDistribution; exports.unwrapSOLInstruction = unwrapSOLInstruction; exports.updateBinArray = updateBinArray; exports.wrapSOLInstruction = wrapSOLInstruction;
+
+
+
+
+
+
+
+
+
+exports.ADMIN = ADMIN; exports.ActionType = ActionType; exports.ActivationType = ActivationType; exports.BASIS_POINT_MAX = BASIS_POINT_MAX; exports.BIN_ARRAY_BITMAP_FEE = BIN_ARRAY_BITMAP_FEE; exports.BIN_ARRAY_BITMAP_FEE_BN = BIN_ARRAY_BITMAP_FEE_BN; exports.BIN_ARRAY_BITMAP_SIZE = BIN_ARRAY_BITMAP_SIZE; exports.BIN_ARRAY_FEE = BIN_ARRAY_FEE; exports.BIN_ARRAY_FEE_BN = BIN_ARRAY_FEE_BN; exports.BinLiquidity = BinLiquidity; exports.BitmapType = BitmapType; exports.ClockLayout = ClockLayout; exports.DEFAULT_BIN_PER_POSITION = DEFAULT_BIN_PER_POSITION; exports.DLMMError = DLMMError; exports.DlmmSdkError = DlmmSdkError; exports.EXTENSION_BINARRAY_BITMAP_SIZE = EXTENSION_BINARRAY_BITMAP_SIZE; exports.FEE_PRECISION = FEE_PRECISION; exports.IDL = dlmm_default; exports.ILM_BASE = ILM_BASE; exports.LBCLMM_PROGRAM_IDS = LBCLMM_PROGRAM_IDS; exports.MAX_ACTIVE_BIN_SLIPPAGE = MAX_ACTIVE_BIN_SLIPPAGE; exports.MAX_BINS_PER_POSITION = MAX_BINS_PER_POSITION; exports.MAX_BIN_ARRAY_SIZE = MAX_BIN_ARRAY_SIZE; exports.MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX = MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX; exports.MAX_CLAIM_ALL_ALLOWED = MAX_CLAIM_ALL_ALLOWED; exports.MAX_EXTRA_BIN_ARRAYS = MAX_EXTRA_BIN_ARRAYS; exports.MAX_FEE_RATE = MAX_FEE_RATE; exports.MAX_RESIZE_LENGTH = MAX_RESIZE_LENGTH; exports.MEMO_PROGRAM_ID = MEMO_PROGRAM_ID; exports.Network = Network; exports.POOL_FEE = POOL_FEE; exports.POOL_FEE_BN = POOL_FEE_BN; exports.POSITION_BIN_DATA_SIZE = POSITION_BIN_DATA_SIZE; exports.POSITION_FEE = POSITION_FEE; exports.POSITION_FEE_BN = POSITION_FEE_BN; exports.POSITION_MAX_LENGTH = POSITION_MAX_LENGTH; exports.POSITION_MIN_SIZE = POSITION_MIN_SIZE; exports.PRECISION = PRECISION; exports.PairStatus = PairStatus; exports.PairType = PairType; exports.PositionVersion = PositionVersion; exports.RebalancePosition = RebalancePosition; exports.ResizeSide = ResizeSide; exports.SCALE = SCALE; exports.SCALE_OFFSET = SCALE_OFFSET; exports.SIMULATION_USER = SIMULATION_USER; exports.Strategy = Strategy; exports.StrategyType = StrategyType; exports.TOKEN_ACCOUNT_FEE = TOKEN_ACCOUNT_FEE; exports.TOKEN_ACCOUNT_FEE_BN = TOKEN_ACCOUNT_FEE_BN; exports.U64_MAX = U64_MAX; exports.autoFillXByStrategy = autoFillXByStrategy; exports.autoFillXByWeight = autoFillXByWeight; exports.autoFillYByStrategy = autoFillYByStrategy; exports.autoFillYByWeight = autoFillYByWeight; exports.binIdToBinArrayIndex = binIdToBinArrayIndex; exports.buildBitFlagAndNegateStrategyParameters = buildBitFlagAndNegateStrategyParameters; exports.buildLiquidityStrategyParameters = buildLiquidityStrategyParameters; exports.calculateBidAskDistribution = calculateBidAskDistribution; exports.calculateNormalDistribution = calculateNormalDistribution; exports.calculateSpotDistribution = calculateSpotDistribution; exports.capSlippagePercentage = capSlippagePercentage; exports.chunkDepositWithRebalanceEndpoint = chunkDepositWithRebalanceEndpoint; exports.chunkedFetchMultipleBinArrayBitmapExtensionAccount = chunkedFetchMultipleBinArrayBitmapExtensionAccount; exports.chunkedFetchMultiplePoolAccount = chunkedFetchMultiplePoolAccount; exports.chunkedGetMultipleAccountInfos = chunkedGetMultipleAccountInfos; exports.chunks = chunks; exports.computeFee = computeFee; exports.computeFeeFromAmount = computeFeeFromAmount; exports.computeProtocolFee = computeProtocolFee; exports.createProgram = createProgram; exports.decodeAccount = decodeAccount; exports.default = src_default; exports.deriveBinArray = deriveBinArray; exports.deriveBinArrayBitmapExtension = deriveBinArrayBitmapExtension; exports.deriveCustomizablePermissionlessLbPair = deriveCustomizablePermissionlessLbPair; exports.deriveEventAuthority = deriveEventAuthority; exports.deriveLbPair = deriveLbPair; exports.deriveLbPair2 = deriveLbPair2; exports.deriveLbPairWithPresetParamWithIndexKey = deriveLbPairWithPresetParamWithIndexKey; exports.deriveOracle = deriveOracle; exports.derivePermissionLbPair = derivePermissionLbPair; exports.derivePlaceHolderAccountMeta = derivePlaceHolderAccountMeta; exports.derivePosition = derivePosition; exports.derivePresetParameter = derivePresetParameter; exports.derivePresetParameter2 = derivePresetParameter2; exports.derivePresetParameterWithIndex = derivePresetParameterWithIndex; exports.deriveReserve = deriveReserve; exports.deriveRewardVault = deriveRewardVault; exports.deriveTokenBadge = deriveTokenBadge; exports.enumerateBins = enumerateBins; exports.findNextBinArrayIndexWithLiquidity = findNextBinArrayIndexWithLiquidity; exports.findNextBinArrayWithLiquidity = findNextBinArrayWithLiquidity; exports.fromWeightDistributionToAmount = fromWeightDistributionToAmount; exports.fromWeightDistributionToAmountOneSide = fromWeightDistributionToAmountOneSide; exports.getAccountDiscriminator = getAccountDiscriminator; exports.getAmountInBinsAskSide = getAmountInBinsAskSide; exports.getAmountInBinsBidSide = getAmountInBinsBidSide; exports.getAndCapMaxActiveBinSlippage = getAndCapMaxActiveBinSlippage; exports.getAutoFillAmountByRebalancedPosition = getAutoFillAmountByRebalancedPosition; exports.getBaseFee = getBaseFee; exports.getBinArrayLowerUpperBinId = getBinArrayLowerUpperBinId; exports.getBinArraysRequiredByPositionRange = getBinArraysRequiredByPositionRange; exports.getBinCount = getBinCount; exports.getBinFromBinArray = getBinFromBinArray; exports.getBinIdIndexInBinArray = getBinIdIndexInBinArray; exports.getEstimatedComputeUnitIxWithBuffer = getEstimatedComputeUnitIxWithBuffer; exports.getEstimatedComputeUnitUsageWithBuffer = getEstimatedComputeUnitUsageWithBuffer; exports.getLiquidityStrategyParameterBuilder = getLiquidityStrategyParameterBuilder; exports.getOrCreateATAInstruction = getOrCreateATAInstruction; exports.getOutAmount = getOutAmount; exports.getPositionCountByBinCount = getPositionCountByBinCount; exports.getPriceOfBinByBinId = getPriceOfBinByBinId; exports.getRebalanceBinArrayIndexesAndBitmapCoverage = getRebalanceBinArrayIndexesAndBitmapCoverage; exports.getSlippageMaxAmount = getSlippageMaxAmount; exports.getSlippageMinAmount = getSlippageMinAmount; exports.getTokenBalance = getTokenBalance; exports.getTokenDecimals = getTokenDecimals; exports.getTokenProgramId = getTokenProgramId; exports.getTokensMintFromPoolAddress = getTokensMintFromPoolAddress; exports.getTotalFee = getTotalFee; exports.getVariableFee = getVariableFee; exports.isBinIdWithinBinArray = isBinIdWithinBinArray; exports.isOverflowDefaultBinArrayBitmap = isOverflowDefaultBinArrayBitmap; exports.parseLogs = parseLogs; exports.range = range; exports.resetUninvolvedLiquidityParams = resetUninvolvedLiquidityParams; exports.suggestBalancedXParametersFromY = suggestBalancedXParametersFromY; exports.suggestBalancedYParametersFromX = suggestBalancedYParametersFromX; exports.swapExactInQuoteAtBin = swapExactInQuoteAtBin; exports.swapExactOutQuoteAtBin = swapExactOutQuoteAtBin; exports.toAmountAskSide = toAmountAskSide; exports.toAmountBidSide = toAmountBidSide; exports.toAmountBothSide = toAmountBothSide; exports.toAmountIntoBins = toAmountIntoBins; exports.toAmountsBothSideByStrategy = toAmountsBothSideByStrategy; exports.toStrategyParameters = toStrategyParameters; exports.toWeightDistribution = toWeightDistribution; exports.unwrapSOLInstruction = unwrapSOLInstruction; exports.updateBinArray = updateBinArray; exports.wrapSOLInstruction = wrapSOLInstruction;
 //# sourceMappingURL=index.js.map