@meteora-ag/dlmm 1.9.13 → 1.9.14

package/dist/index.mjs

@@ -10448,7 +10448,7 @@ var LimitOrderStatus = /* @__PURE__ */ ((LimitOrderStatus2) => {
 })(LimitOrderStatus || {});
 
 // src/dlmm/helpers/binArray.ts
-import { BN as BN8 } from "@coral-xyz/anchor";
+import { BN as BN10 } from "@coral-xyz/anchor";
 import { PublicKey as PublicKey5 } from "@solana/web3.js";
 
 // src/dlmm/helpers/derive.ts
@@ -11811,137 +11811,422 @@ function generateBinAmount(amount, binStep, binId, tokenXDecimal, tokenYDecimal,
   return new BN7(c1.sub(c0).floor().toString());
 }
 
-// src/dlmm/helpers/binArray.ts
-function internalBitmapRange() {
-  const lowerBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.neg();
-  const upperBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.sub(new BN8(1));
-  return [lowerBinArrayIndex, upperBinArrayIndex];
-}
-function buildBitmapFromU64Arrays(u64Arrays, type) {
-  const buffer = Buffer.concat(
-    u64Arrays.map((b) => {
-      return b.toArrayLike(Buffer, "le", 8);
-    })
-  );
-  return new BN8(buffer, "le");
+// src/dlmm/helpers/positions/index.ts
+import BN9 from "bn.js";
+
+// src/dlmm/helpers/positions/wrapper.ts
+import BN8 from "bn.js";
+function combineBaseAndExtendedPositionBinData(base, extended) {
+  const combinedLiquidityShares = base.liquidityShares;
+  const combinedRewardInfos = base.rewardInfos;
+  const combinedFeeInfos = base.feeInfos;
+  for (const binData of extended) {
+    combinedLiquidityShares.push(binData.liquidityShare);
+    combinedRewardInfos.push(binData.rewardInfo);
+    combinedFeeInfos.push(binData.feeInfo);
+  }
+  return {
+    liquidityShares: combinedLiquidityShares,
+    rewardInfos: combinedRewardInfos,
+    feeInfos: combinedFeeInfos
+  };
 }
-function bitmapTypeDetail(type) {
-  if (type == 0 /* U1024 */) {
-    return {
-      bits: 1024,
-      bytes: 1024 / 8
-    };
+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 {
-    return {
-      bits: 512,
-      bytes: 512 / 8
-    };
+    throw new Error("Unknown position account");
   }
 }
-function mostSignificantBit(number, bitLength) {
-  const highestIndex = bitLength - 1;
-  if (number.isZero()) {
-    return null;
+var PositionV2Wrapper = class {
+  constructor(positionAddress, inner, extended, combinedPositionBinData) {
+    this.positionAddress = positionAddress;
+    this.inner = inner;
+    this.extended = extended;
+    this.combinedPositionBinData = combinedPositionBinData;
   }
-  for (let i = highestIndex; i >= 0; i--) {
-    if (number.testn(i)) {
-      return highestIndex - i;
-    }
+  address() {
+    return this.positionAddress;
   }
-  return null;
-}
-function leastSignificantBit(number, bitLength) {
-  if (number.isZero()) {
-    return null;
+  totalClaimedRewards() {
+    return this.inner.totalClaimedRewards;
   }
-  for (let i = 0; i < bitLength; i++) {
-    if (number.testn(i)) {
-      return i;
+  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 BN8(this.inner.lowerBinId);
+  }
+  upperBinId() {
+    return new BN8(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 BN8(1));
+      return [lowerBinArrayIndex, upperBinArrayIndex];
     }
   }
-  return null;
+  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 BN8(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 BN9(i));
+  }
+  return binArrayIndexes;
 }
-function extensionBitmapRange() {
-  return [
-    BIN_ARRAY_BITMAP_SIZE.neg().mul(
-      EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN8(1))
-    ),
-    BIN_ARRAY_BITMAP_SIZE.mul(
-      EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN8(1))
-    ).sub(new BN8(1))
-  ];
+function getBinArrayKeysCoverage(lowerBinId, upperBinId, lbPair, programId) {
+  const binArrayIndexes = getBinArrayIndexesCoverage(lowerBinId, upperBinId);
+  return binArrayIndexes.map((index) => {
+    return deriveBinArray(lbPair, index, programId)[0];
+  });
 }
-function findSetBit(startIndex, endIndex, binArrayBitmapExtension) {
-  const getBinArrayOffset = (binArrayIndex) => {
-    return binArrayIndex.gt(new BN8(0)) ? binArrayIndex.mod(BIN_ARRAY_BITMAP_SIZE) : binArrayIndex.add(new BN8(1)).neg().mod(BIN_ARRAY_BITMAP_SIZE);
-  };
-  const getBitmapOffset = (binArrayIndex) => {
-    return binArrayIndex.gt(new BN8(0)) ? binArrayIndex.div(BIN_ARRAY_BITMAP_SIZE).sub(new BN8(1)) : binArrayIndex.add(new BN8(1)).neg().div(BIN_ARRAY_BITMAP_SIZE).sub(new BN8(1));
-  };
-  if (startIndex <= endIndex) {
-    for (let i = startIndex; i <= endIndex; i++) {
-      const binArrayOffset = getBinArrayOffset(new BN8(i)).toNumber();
-      const bitmapOffset = getBitmapOffset(new BN8(i)).toNumber();
-      const bitmapChunks = i > 0 ? binArrayBitmapExtension.positiveBinArrayBitmap[bitmapOffset] : binArrayBitmapExtension.negativeBinArrayBitmap[bitmapOffset];
-      const bitmap = buildBitmapFromU64Arrays(bitmapChunks, 1 /* U512 */);
-      if (bitmap.testn(binArrayOffset)) {
-        return i;
-      }
-    }
-  } else {
-    for (let i = startIndex; i >= endIndex; i--) {
-      const binArrayOffset = getBinArrayOffset(new BN8(i)).toNumber();
-      const bitmapOffset = getBitmapOffset(new BN8(i)).toNumber();
-      const bitmapChunks = i > 0 ? binArrayBitmapExtension.positiveBinArrayBitmap[bitmapOffset] : binArrayBitmapExtension.negativeBinArrayBitmap[bitmapOffset];
-      const bitmap = buildBitmapFromU64Arrays(bitmapChunks, 1 /* U512 */);
-      if (bitmap.testn(binArrayOffset)) {
-        return i;
-      }
+function getBinArrayAccountMetasCoverage(lowerBinId, upperBinId, lbPair, programId) {
+  return getBinArrayKeysCoverage(lowerBinId, upperBinId, lbPair, programId).map(
+    (key) => {
+      return {
+        pubkey: key,
+        isSigner: false,
+        isWritable: true
+      };
     }
-  }
-  return null;
-}
-function isOverflowDefaultBinArrayBitmap(binArrayIndex) {
-  const [minBinArrayIndex, maxBinArrayIndex] = internalBitmapRange();
-  return binArrayIndex.gt(maxBinArrayIndex) || binArrayIndex.lt(minBinArrayIndex);
+  );
 }
-function deriveBinArrayBitmapExtension(lbPair, programId) {
-  return PublicKey5.findProgramAddressSync(
-    [Buffer.from("bitmap"), lbPair.toBytes()],
-    programId
+function getPositionLowerUpperBinIdWithLiquidity(position) {
+  const binWithLiquidity = position.positionBinData.filter(
+    (b) => !new BN9(b.binLiquidity).isZero() || !new BN9(b.positionFeeXAmount.toString()).isZero() || !new BN9(b.positionFeeYAmount.toString()).isZero() || !new BN9(b.positionRewardAmount[0].toString()).isZero() || !new BN9(b.positionRewardAmount[1].toString()).isZero()
   );
+  return binWithLiquidity.length > 0 ? {
+    lowerBinId: new BN9(binWithLiquidity[0].binId),
+    upperBinId: new BN9(binWithLiquidity[binWithLiquidity.length - 1].binId)
+  } : null;
 }
-function binIdToBinArrayIndex(binId) {
-  const { div: idx, mod } = binId.divmod(MAX_BIN_ARRAY_SIZE);
-  return binId.isNeg() && !mod.isZero() ? idx.sub(new BN8(1)) : idx;
+function isPositionNoFee(position) {
+  return position.feeX.isZero() && position.feeY.isZero();
 }
-function getBinArrayLowerUpperBinId(binArrayIndex) {
-  const lowerBinId = binArrayIndex.mul(MAX_BIN_ARRAY_SIZE);
-  const upperBinId = lowerBinId.add(MAX_BIN_ARRAY_SIZE).sub(new BN8(1));
-  return [lowerBinId, upperBinId];
+function isPositionNoReward(position) {
+  return position.rewardOne.isZero() && position.rewardTwo.isZero();
 }
-function isBinIdWithinBinArray(activeId, binArrayIndex) {
-  const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(binArrayIndex);
-  return activeId.gte(lowerBinId) && activeId.lte(upperBinId);
+function chunkBinRangeIntoExtendedPositions(minBinId, maxBinId) {
+  const chunkedBinRange = [];
+  for (let currentMinBinId = minBinId; currentMinBinId <= maxBinId; currentMinBinId += POSITION_MAX_LENGTH.toNumber()) {
+    const currentMaxBinId = Math.min(
+      currentMinBinId + POSITION_MAX_LENGTH.toNumber() - 1,
+      maxBinId
+    );
+    chunkedBinRange.push({
+      lowerBinId: currentMinBinId,
+      upperBinId: currentMaxBinId
+    });
+  }
+  return chunkedBinRange;
 }
-function getBinFromBinArray(binId, binArray) {
-  const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(binArray.index);
-  let index = 0;
-  if (binId > 0) {
-    index = binId - lowerBinId.toNumber();
-  } else {
-    const delta = upperBinId.toNumber() - binId;
-    index = MAX_BIN_ARRAY_SIZE.toNumber() - delta - 1;
+function chunkBinRange(minBinId, maxBinId, binPerChunk) {
+  const chunkedBinRange = [];
+  let startBinId = minBinId;
+  binPerChunk = binPerChunk ?? DEFAULT_BIN_PER_POSITION.toNumber();
+  while (startBinId <= maxBinId) {
+    const endBinId = Math.min(startBinId + binPerChunk - 1, maxBinId);
+    chunkedBinRange.push({
+      lowerBinId: startBinId,
+      upperBinId: endBinId
+    });
+    startBinId += binPerChunk;
   }
-  return binArray.bins[index];
+  return chunkedBinRange;
 }
-function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, binArrayBitmapExtension) {
-  const [lowerBinArrayIndex, upperBinArrayIndex] = internalBitmapRange();
-  let startBinArrayIndex = binIdToBinArrayIndex(activeId);
-  while (true) {
-    if (isOverflowDefaultBinArrayBitmap(startBinArrayIndex)) {
-      if (binArrayBitmapExtension === null) {
-        return null;
+function chunkPositionBinRange(position, minBinId, maxBinId) {
+  const chunkedFeesAndRewards = [];
+  let totalAmountX = new BN9(0);
+  let totalAmountY = new BN9(0);
+  let totalFeeXAmount = new BN9(0);
+  let totalFeeYAmount = new BN9(0);
+  let totalRewardAmounts = [new BN9(0), new BN9(0)];
+  let count = 0;
+  for (let i = 0; i < position.positionData.positionBinData.length; i++) {
+    const positionBinData = position.positionData.positionBinData[i];
+    if (positionBinData.binId >= minBinId && positionBinData.binId <= maxBinId) {
+      totalFeeXAmount = totalFeeXAmount.add(
+        new BN9(positionBinData.positionFeeXAmount)
+      );
+      totalFeeYAmount = totalFeeYAmount.add(
+        new BN9(positionBinData.positionFeeYAmount)
+      );
+      totalAmountX = totalAmountX.add(new BN9(positionBinData.positionXAmount));
+      totalAmountY = totalAmountY.add(new BN9(positionBinData.positionYAmount));
+      for (const [
+        index,
+        reward
+      ] of positionBinData.positionRewardAmount.entries()) {
+        totalRewardAmounts[index] = totalRewardAmounts[index].add(
+          new BN9(reward)
+        );
+      }
+      count++;
+    }
+    if (count === DEFAULT_BIN_PER_POSITION.toNumber() || positionBinData.binId == maxBinId) {
+      chunkedFeesAndRewards.push({
+        minBinId: positionBinData.binId - count + 1,
+        maxBinId: positionBinData.binId,
+        feeXAmount: totalFeeXAmount,
+        feeYAmount: totalFeeYAmount,
+        rewardAmounts: totalRewardAmounts,
+        amountX: totalAmountX,
+        amountY: totalAmountY
+      });
+      totalFeeXAmount = new BN9(0);
+      totalFeeYAmount = new BN9(0);
+      totalAmountX = new BN9(0);
+      totalAmountY = new BN9(0);
+      totalRewardAmounts = [new BN9(0), new BN9(0)];
+      count = 0;
+    }
+  }
+  return chunkedFeesAndRewards;
+}
+function calculatePositionSize(binCount) {
+  const extraBinCount = binCount.gt(DEFAULT_BIN_PER_POSITION) ? binCount.sub(DEFAULT_BIN_PER_POSITION) : new BN9(0);
+  return new BN9(POSITION_MIN_SIZE).add(
+    extraBinCount.mul(new BN9(POSITION_BIN_DATA_SIZE))
+  );
+}
+function getPositionRentExemption(connection, binCount) {
+  const size = calculatePositionSize(binCount);
+  return connection.getMinimumBalanceForRentExemption(size.toNumber());
+}
+async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
+  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
+  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
+  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
+    return 0;
+  } else {
+    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
+      DEFAULT_BIN_PER_POSITION
+    );
+    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
+    const [minimumLamports, rentExemptionLamports] = await Promise.all([
+      connection.getMinimumBalanceForRentExemption(0),
+      connection.getMinimumBalanceForRentExemption(expandSize)
+    ]);
+    return rentExemptionLamports - minimumLamports;
+  }
+}
+function getExtendedPositionBinCount(minBinId, maxBinId) {
+  const width = maxBinId.sub(minBinId).addn(1);
+  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
+  return extended.lte(new BN9(0)) ? new BN9(0) : extended;
+}
+function decodeExtendedPosition(base, program, bytes) {
+  const width = base.upperBinId - base.lowerBinId + 1;
+  const extendedWidth = width - DEFAULT_BIN_PER_POSITION.toNumber();
+  const extendedPosition = [];
+  for (let i = 0; i < extendedWidth; i++) {
+    const offset = i * POSITION_BIN_DATA_SIZE;
+    const data = bytes.subarray(offset, offset + POSITION_BIN_DATA_SIZE);
+    const decodedPositionBinData = program.coder.types.decode(
+      // TODO: Find a type safe way
+      "positionBinData",
+      data
+    );
+    extendedPosition.push(decodedPositionBinData);
+  }
+  return extendedPosition;
+}
+
+// src/dlmm/helpers/binArray.ts
+function internalBitmapRange() {
+  const lowerBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.neg();
+  const upperBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.sub(new BN10(1));
+  return [lowerBinArrayIndex, upperBinArrayIndex];
+}
+function buildBitmapFromU64Arrays(u64Arrays, type) {
+  const buffer = Buffer.concat(
+    u64Arrays.map((b) => {
+      return b.toArrayLike(Buffer, "le", 8);
+    })
+  );
+  return new BN10(buffer, "le");
+}
+function bitmapTypeDetail(type) {
+  if (type == 0 /* U1024 */) {
+    return {
+      bits: 1024,
+      bytes: 1024 / 8
+    };
+  } else {
+    return {
+      bits: 512,
+      bytes: 512 / 8
+    };
+  }
+}
+function mostSignificantBit(number, bitLength) {
+  const highestIndex = bitLength - 1;
+  if (number.isZero()) {
+    return null;
+  }
+  for (let i = highestIndex; i >= 0; i--) {
+    if (number.testn(i)) {
+      return highestIndex - i;
+    }
+  }
+  return null;
+}
+function leastSignificantBit(number, bitLength) {
+  if (number.isZero()) {
+    return null;
+  }
+  for (let i = 0; i < bitLength; i++) {
+    if (number.testn(i)) {
+      return i;
+    }
+  }
+  return null;
+}
+function extensionBitmapRange() {
+  return [
+    BIN_ARRAY_BITMAP_SIZE.neg().mul(
+      EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN10(1))
+    ),
+    BIN_ARRAY_BITMAP_SIZE.mul(
+      EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN10(1))
+    ).sub(new BN10(1))
+  ];
+}
+function findSetBit(startIndex, endIndex, binArrayBitmapExtension) {
+  const getBinArrayOffset = (binArrayIndex) => {
+    return binArrayIndex.gt(new BN10(0)) ? binArrayIndex.mod(BIN_ARRAY_BITMAP_SIZE) : binArrayIndex.add(new BN10(1)).neg().mod(BIN_ARRAY_BITMAP_SIZE);
+  };
+  const getBitmapOffset = (binArrayIndex) => {
+    return binArrayIndex.gt(new BN10(0)) ? binArrayIndex.div(BIN_ARRAY_BITMAP_SIZE).sub(new BN10(1)) : binArrayIndex.add(new BN10(1)).neg().div(BIN_ARRAY_BITMAP_SIZE).sub(new BN10(1));
+  };
+  if (startIndex <= endIndex) {
+    for (let i = startIndex; i <= endIndex; i++) {
+      const binArrayOffset = getBinArrayOffset(new BN10(i)).toNumber();
+      const bitmapOffset = getBitmapOffset(new BN10(i)).toNumber();
+      const bitmapChunks = i > 0 ? binArrayBitmapExtension.positiveBinArrayBitmap[bitmapOffset] : binArrayBitmapExtension.negativeBinArrayBitmap[bitmapOffset];
+      const bitmap = buildBitmapFromU64Arrays(bitmapChunks, 1 /* U512 */);
+      if (bitmap.testn(binArrayOffset)) {
+        return i;
+      }
+    }
+  } else {
+    for (let i = startIndex; i >= endIndex; i--) {
+      const binArrayOffset = getBinArrayOffset(new BN10(i)).toNumber();
+      const bitmapOffset = getBitmapOffset(new BN10(i)).toNumber();
+      const bitmapChunks = i > 0 ? binArrayBitmapExtension.positiveBinArrayBitmap[bitmapOffset] : binArrayBitmapExtension.negativeBinArrayBitmap[bitmapOffset];
+      const bitmap = buildBitmapFromU64Arrays(bitmapChunks, 1 /* U512 */);
+      if (bitmap.testn(binArrayOffset)) {
+        return i;
+      }
+    }
+  }
+  return null;
+}
+function isOverflowDefaultBinArrayBitmap(binArrayIndex) {
+  const [minBinArrayIndex, maxBinArrayIndex] = internalBitmapRange();
+  return binArrayIndex.gt(maxBinArrayIndex) || binArrayIndex.lt(minBinArrayIndex);
+}
+function deriveBinArrayBitmapExtension(lbPair, programId) {
+  return PublicKey5.findProgramAddressSync(
+    [Buffer.from("bitmap"), lbPair.toBytes()],
+    programId
+  );
+}
+function binIdToBinArrayIndex(binId) {
+  const { div: idx, mod } = binId.divmod(MAX_BIN_ARRAY_SIZE);
+  return binId.isNeg() && !mod.isZero() ? idx.sub(new BN10(1)) : idx;
+}
+function getBinArrayLowerUpperBinId(binArrayIndex) {
+  const lowerBinId = binArrayIndex.mul(MAX_BIN_ARRAY_SIZE);
+  const upperBinId = lowerBinId.add(MAX_BIN_ARRAY_SIZE).sub(new BN10(1));
+  return [lowerBinId, upperBinId];
+}
+function isBinIdWithinBinArray(activeId, binArrayIndex) {
+  const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(binArrayIndex);
+  return activeId.gte(lowerBinId) && activeId.lte(upperBinId);
+}
+function getBinFromBinArray(binId, binArray) {
+  const [lowerBinId, upperBinId] = getBinArrayLowerUpperBinId(binArray.index);
+  let index = 0;
+  if (binId > 0) {
+    index = binId - lowerBinId.toNumber();
+  } else {
+    const delta = upperBinId.toNumber() - binId;
+    index = MAX_BIN_ARRAY_SIZE.toNumber() - delta - 1;
+  }
+  return binArray.bins[index];
+}
+function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, binArrayBitmapExtension) {
+  const [lowerBinArrayIndex, upperBinArrayIndex] = internalBitmapRange();
+  let startBinArrayIndex = binIdToBinArrayIndex(activeId);
+  while (true) {
+    if (isOverflowDefaultBinArrayBitmap(startBinArrayIndex)) {
+      if (binArrayBitmapExtension === null) {
+        return null;
       }
       const [minBinArrayIndex, maxBinArrayIndex] = extensionBitmapRange();
       if (startBinArrayIndex.isNeg()) {
@@ -11952,18 +12237,18 @@ function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, bin
             binArrayBitmapExtension
           );
           if (binArrayIndex !== null) {
-            return new BN8(binArrayIndex);
+            return new BN10(binArrayIndex);
           } else {
             return null;
           }
         } else {
           const binArrayIndex = findSetBit(
             startBinArrayIndex.toNumber(),
-            BIN_ARRAY_BITMAP_SIZE.neg().sub(new BN8(1)).toNumber(),
+            BIN_ARRAY_BITMAP_SIZE.neg().sub(new BN10(1)).toNumber(),
             binArrayBitmapExtension
           );
           if (binArrayIndex !== null) {
-            return new BN8(binArrayIndex);
+            return new BN10(binArrayIndex);
           } else {
             startBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.neg();
           }
@@ -11976,9 +12261,9 @@ function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, bin
             binArrayBitmapExtension
           );
           if (binArrayIndex !== null) {
-            return new BN8(binArrayIndex);
+            return new BN10(binArrayIndex);
           } else {
-            startBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.sub(new BN8(1));
+            startBinArrayIndex = BIN_ARRAY_BITMAP_SIZE.sub(new BN10(1));
           }
         } else {
           const binArrayIndex = findSetBit(
@@ -11987,7 +12272,7 @@ function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, bin
             binArrayBitmapExtension
           );
           if (binArrayIndex !== null) {
-            return new BN8(binArrayIndex);
+            return new BN10(binArrayIndex);
           } else {
             return null;
           }
@@ -12002,22 +12287,22 @@ function findNextBinArrayIndexWithLiquidity(swapForY, activeId, lbPairState, bin
         bitmapType
       );
       if (swapForY) {
-        const upperBitRange = new BN8(bitmapDetail.bits - 1).sub(offset);
+        const upperBitRange = new BN10(bitmapDetail.bits - 1).sub(offset);
         const croppedBitmap = bitmap.shln(upperBitRange.toNumber());
         const msb = mostSignificantBit(croppedBitmap, bitmapDetail.bits);
         if (msb !== null) {
-          return startBinArrayIndex.sub(new BN8(msb));
+          return startBinArrayIndex.sub(new BN10(msb));
         } else {
-          startBinArrayIndex = lowerBinArrayIndex.sub(new BN8(1));
+          startBinArrayIndex = lowerBinArrayIndex.sub(new BN10(1));
         }
       } else {
         const lowerBitRange = offset;
         const croppedBitmap = bitmap.shrn(lowerBitRange.toNumber());
         const lsb = leastSignificantBit(croppedBitmap, bitmapDetail.bits);
         if (lsb !== null) {
-          return startBinArrayIndex.add(new BN8(lsb));
+          return startBinArrayIndex.add(new BN10(lsb));
         } else {
-          startBinArrayIndex = upperBinArrayIndex.add(new BN8(1));
+          startBinArrayIndex = upperBinArrayIndex.add(new BN10(1));
         }
       }
     }
@@ -12046,9 +12331,9 @@ function getBinArraysRequiredByPositionRange(pair, fromBinId, toBinId, programId
   const positionCount = getPositionCount(minBinId, maxBinId);
   const binArrays = /* @__PURE__ */ new Map();
   for (let i = 0; i < positionCount.toNumber(); i++) {
-    const lowerBinId = minBinId.add(DEFAULT_BIN_PER_POSITION.mul(new BN8(i)));
+    const lowerBinId = minBinId.add(DEFAULT_BIN_PER_POSITION.mul(new BN10(i)));
     const lowerBinArrayIndex = binIdToBinArrayIndex(lowerBinId);
-    const upperBinArrayIndex = lowerBinArrayIndex.add(new BN8(1));
+    const upperBinArrayIndex = lowerBinArrayIndex.add(new BN10(1));
     const [lowerBinArray] = deriveBinArray(pair, lowerBinArrayIndex, programId);
     const [upperBinArray] = deriveBinArray(pair, upperBinArrayIndex, programId);
     binArrays.set(lowerBinArray.toBase58(), lowerBinArrayIndex);
@@ -12059,6 +12344,17 @@ function getBinArraysRequiredByPositionRange(pair, fromBinId, toBinId, programId
     index
   }));
 }
+function getBinArraysRequiredByPositionRange2(pair, fromBinId, toBinId, programId) {
+  const [minBinId, maxBinId] = fromBinId.lt(toBinId) ? [fromBinId, toBinId] : [toBinId, fromBinId];
+  const binArrayIndexes = getBinArrayIndexesCoverage(minBinId, maxBinId);
+  return Array.from(binArrayIndexes, (index) => {
+    const [binArrayPubkey] = deriveBinArray(pair, index, programId);
+    return {
+      key: binArrayPubkey,
+      index
+    };
+  });
+}
 function* enumerateBins(binsById, lowerBinId, upperBinId, binStep, baseTokenDecimal, quoteTokenDecimal, version, lbPair) {
   for (let currentBinId = lowerBinId; currentBinId <= upperBinId; currentBinId++) {
     const bin = binsById.get(currentBinId);
@@ -12108,7 +12404,7 @@ function decodeRewardPerTokenStored(bin) {
     "le",
     8
   );
-  const rewardPerTokenStored0 = new BN8(
+  const rewardPerTokenStored0 = new BN10(
     Buffer.concat([rewardPerTokenStored0Buf0, rewardPerTokenStored0Buf1]),
     "le"
   );
@@ -12122,7 +12418,7 @@ function decodeRewardPerTokenStored(bin) {
     "le",
     8
   );
-  const rewardPerTokenStored1 = new BN8(
+  const rewardPerTokenStored1 = new BN10(
     Buffer.concat([rewardPerTokenStored1Buf0, rewardPerTokenStored1Buf1]),
     "le"
   );
@@ -12132,7 +12428,7 @@ function getBinArrayInfoForNonContiguousBinIds(binIds, programId, lbPair) {
   let binArrayBitmapExtension = programId;
   const binArrayIndexes = /* @__PURE__ */ new Set();
   for (const binId of binIds) {
-    const binArrayIndex = binIdToBinArrayIndex(new BN8(binId));
+    const binArrayIndex = binIdToBinArrayIndex(new BN10(binId));
     if (isOverflowDefaultBinArrayBitmap(binArrayIndex) && binArrayBitmapExtension.equals(programId)) {
       binArrayBitmapExtension = deriveBinArrayBitmapExtension(
         lbPair,
@@ -12142,7 +12438,7 @@ function getBinArrayInfoForNonContiguousBinIds(binIds, programId, lbPair) {
     binArrayIndexes.add(binArrayIndex.toNumber());
   }
   const binArrayPubkeys = [...binArrayIndexes].map(
-    (idx) => deriveBinArray(lbPair, new BN8(idx), programId)[0]
+    (idx) => deriveBinArray(lbPair, new BN10(idx), programId)[0]
   );
   const binArrayAccountMetas = binArrayPubkeys.map((pubkey) => {
     return {
@@ -12154,7 +12450,7 @@ function getBinArrayInfoForNonContiguousBinIds(binIds, programId, lbPair) {
   return {
     binArrayAccountMetas,
     binArrayBitmapExtension,
-    binArrayIndexes: [...binArrayIndexes].map((idx) => new BN8(idx))
+    binArrayIndexes: [...binArrayIndexes].map((idx) => new BN10(idx))
   };
 }
 
@@ -12213,291 +12509,6 @@ var getSimulationComputeUnits = async (connection, instructions, payer, lookupTa
   return rpcResponse.value.unitsConsumed || null;
 };
 
-// src/dlmm/helpers/positions/index.ts
-import BN10 from "bn.js";
-
-// src/dlmm/helpers/positions/wrapper.ts
-import BN9 from "bn.js";
-function combineBaseAndExtendedPositionBinData(base, extended) {
-  const combinedLiquidityShares = base.liquidityShares;
-  const combinedRewardInfos = base.rewardInfos;
-  const combinedFeeInfos = base.feeInfos;
-  for (const binData of extended) {
-    combinedLiquidityShares.push(binData.liquidityShare);
-    combinedRewardInfos.push(binData.rewardInfo);
-    combinedFeeInfos.push(binData.feeInfo);
-  }
-  return {
-    liquidityShares: combinedLiquidityShares,
-    rewardInfos: combinedRewardInfos,
-    feeInfos: combinedFeeInfos
-  };
-}
-function wrapPosition(program, key, account) {
-  const disc = account.data.subarray(0, 8);
-  if (disc.equals(Buffer.from(getAccountDiscriminator("positionV2")))) {
-    const state = decodeAccount(
-      program,
-      "positionV2",
-      account.data
-    );
-    const extended = decodeExtendedPosition(
-      state,
-      program,
-      account.data.subarray(8 + POSITION_MIN_SIZE)
-    );
-    const combinedPositionBinData = combineBaseAndExtendedPositionBinData(
-      state,
-      extended
-    );
-    return new PositionV2Wrapper(key, state, extended, combinedPositionBinData);
-  } else {
-    throw new Error("Unknown position account");
-  }
-}
-var PositionV2Wrapper = class {
-  constructor(positionAddress, inner, extended, combinedPositionBinData) {
-    this.positionAddress = positionAddress;
-    this.inner = inner;
-    this.extended = extended;
-    this.combinedPositionBinData = combinedPositionBinData;
-  }
-  address() {
-    return this.positionAddress;
-  }
-  totalClaimedRewards() {
-    return this.inner.totalClaimedRewards;
-  }
-  feeOwner() {
-    return this.inner.feeOwner;
-  }
-  lockReleasePoint() {
-    return this.inner.lockReleasePoint;
-  }
-  operator() {
-    return this.inner.operator;
-  }
-  totalClaimedFeeYAmount() {
-    return this.inner.totalClaimedFeeYAmount;
-  }
-  totalClaimedFeeXAmount() {
-    return this.inner.totalClaimedFeeXAmount;
-  }
-  lbPair() {
-    return this.inner.lbPair;
-  }
-  lowerBinId() {
-    return new BN9(this.inner.lowerBinId);
-  }
-  upperBinId() {
-    return new BN9(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 BN9(1));
-      return [lowerBinArrayIndex, upperBinArrayIndex];
-    }
-  }
-  getBinArrayKeysCoverage(programId) {
-    return this.getBinArrayIndexesCoverage().map(
-      (index) => deriveBinArray(this.lbPair(), index, programId)[0]
-    );
-  }
-  version() {
-    return 1 /* V2 */;
-  }
-  owner() {
-    return this.inner.owner;
-  }
-  width() {
-    return this.upperBinId().sub(this.lowerBinId()).add(new BN9(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 BN10(i));
-  }
-  return binArrayIndexes;
-}
-function getBinArrayKeysCoverage(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 getBinArrayKeysCoverage(lowerBinId, upperBinId, lbPair, programId).map(
-    (key) => {
-      return {
-        pubkey: key,
-        isSigner: false,
-        isWritable: true
-      };
-    }
-  );
-}
-function getPositionLowerUpperBinIdWithLiquidity(position) {
-  const binWithLiquidity = position.positionBinData.filter(
-    (b) => !new BN10(b.binLiquidity).isZero() || !new BN10(b.positionFeeXAmount.toString()).isZero() || !new BN10(b.positionFeeYAmount.toString()).isZero() || !new BN10(b.positionRewardAmount[0].toString()).isZero() || !new BN10(b.positionRewardAmount[1].toString()).isZero()
-  );
-  return binWithLiquidity.length > 0 ? {
-    lowerBinId: new BN10(binWithLiquidity[0].binId),
-    upperBinId: new BN10(binWithLiquidity[binWithLiquidity.length - 1].binId)
-  } : null;
-}
-function isPositionNoFee(position) {
-  return position.feeX.isZero() && position.feeY.isZero();
-}
-function isPositionNoReward(position) {
-  return position.rewardOne.isZero() && position.rewardTwo.isZero();
-}
-function chunkBinRangeIntoExtendedPositions(minBinId, maxBinId) {
-  const chunkedBinRange = [];
-  for (let currentMinBinId = minBinId; currentMinBinId <= maxBinId; currentMinBinId += POSITION_MAX_LENGTH.toNumber()) {
-    const currentMaxBinId = Math.min(
-      currentMinBinId + POSITION_MAX_LENGTH.toNumber() - 1,
-      maxBinId
-    );
-    chunkedBinRange.push({
-      lowerBinId: currentMinBinId,
-      upperBinId: currentMaxBinId
-    });
-  }
-  return chunkedBinRange;
-}
-function chunkBinRange(minBinId, maxBinId, binPerChunk) {
-  const chunkedBinRange = [];
-  let startBinId = minBinId;
-  binPerChunk = binPerChunk ?? DEFAULT_BIN_PER_POSITION.toNumber();
-  while (startBinId <= maxBinId) {
-    const endBinId = Math.min(startBinId + binPerChunk - 1, maxBinId);
-    chunkedBinRange.push({
-      lowerBinId: startBinId,
-      upperBinId: endBinId
-    });
-    startBinId += binPerChunk;
-  }
-  return chunkedBinRange;
-}
-function chunkPositionBinRange(position, minBinId, maxBinId) {
-  const chunkedFeesAndRewards = [];
-  let totalAmountX = new BN10(0);
-  let totalAmountY = new BN10(0);
-  let totalFeeXAmount = new BN10(0);
-  let totalFeeYAmount = new BN10(0);
-  let totalRewardAmounts = [new BN10(0), new BN10(0)];
-  let count = 0;
-  for (let i = 0; i < position.positionData.positionBinData.length; i++) {
-    const positionBinData = position.positionData.positionBinData[i];
-    if (positionBinData.binId >= minBinId && positionBinData.binId <= maxBinId) {
-      totalFeeXAmount = totalFeeXAmount.add(
-        new BN10(positionBinData.positionFeeXAmount)
-      );
-      totalFeeYAmount = totalFeeYAmount.add(
-        new BN10(positionBinData.positionFeeYAmount)
-      );
-      totalAmountX = totalAmountX.add(new BN10(positionBinData.positionXAmount));
-      totalAmountY = totalAmountY.add(new BN10(positionBinData.positionYAmount));
-      for (const [
-        index,
-        reward
-      ] of positionBinData.positionRewardAmount.entries()) {
-        totalRewardAmounts[index] = totalRewardAmounts[index].add(
-          new BN10(reward)
-        );
-      }
-      count++;
-    }
-    if (count === DEFAULT_BIN_PER_POSITION.toNumber() || positionBinData.binId == maxBinId) {
-      chunkedFeesAndRewards.push({
-        minBinId: positionBinData.binId - count + 1,
-        maxBinId: positionBinData.binId,
-        feeXAmount: totalFeeXAmount,
-        feeYAmount: totalFeeYAmount,
-        rewardAmounts: totalRewardAmounts,
-        amountX: totalAmountX,
-        amountY: totalAmountY
-      });
-      totalFeeXAmount = new BN10(0);
-      totalFeeYAmount = new BN10(0);
-      totalAmountX = new BN10(0);
-      totalAmountY = new BN10(0);
-      totalRewardAmounts = [new BN10(0), new BN10(0)];
-      count = 0;
-    }
-  }
-  return chunkedFeesAndRewards;
-}
-function calculatePositionSize(binCount) {
-  const extraBinCount = binCount.gt(DEFAULT_BIN_PER_POSITION) ? binCount.sub(DEFAULT_BIN_PER_POSITION) : new BN10(0);
-  return new BN10(POSITION_MIN_SIZE).add(
-    extraBinCount.mul(new BN10(POSITION_BIN_DATA_SIZE))
-  );
-}
-function getPositionRentExemption(connection, binCount) {
-  const size = calculatePositionSize(binCount);
-  return connection.getMinimumBalanceForRentExemption(size.toNumber());
-}
-async function getPositionExpandRentExemption(currentMinBinId, currentMaxBinId, connection, binCountToExpand) {
-  const currentPositionWidth = currentMaxBinId.sub(currentMinBinId).addn(1);
-  const positionWidthAfterExpand = currentPositionWidth.add(binCountToExpand);
-  if (positionWidthAfterExpand.lte(DEFAULT_BIN_PER_POSITION)) {
-    return 0;
-  } else {
-    const binCountInExpandedBytes = positionWidthAfterExpand.sub(
-      DEFAULT_BIN_PER_POSITION
-    );
-    const expandSize = binCountInExpandedBytes.toNumber() * POSITION_BIN_DATA_SIZE;
-    const [minimumLamports, rentExemptionLamports] = await Promise.all([
-      connection.getMinimumBalanceForRentExemption(0),
-      connection.getMinimumBalanceForRentExemption(expandSize)
-    ]);
-    return rentExemptionLamports - minimumLamports;
-  }
-}
-function getExtendedPositionBinCount(minBinId, maxBinId) {
-  const width = maxBinId.sub(minBinId).addn(1);
-  const extended = width.sub(DEFAULT_BIN_PER_POSITION);
-  return extended.lte(new BN10(0)) ? new BN10(0) : extended;
-}
-function decodeExtendedPosition(base, program, bytes) {
-  const width = base.upperBinId - base.lowerBinId + 1;
-  const extendedWidth = width - DEFAULT_BIN_PER_POSITION.toNumber();
-  const extendedPosition = [];
-  for (let i = 0; i < extendedWidth; i++) {
-    const offset = i * POSITION_BIN_DATA_SIZE;
-    const data = bytes.subarray(offset, offset + POSITION_BIN_DATA_SIZE);
-    const decodedPositionBinData = program.coder.types.decode(
-      // TODO: Find a type safe way
-      "positionBinData",
-      data
-    );
-    extendedPosition.push(decodedPositionBinData);
-  }
-  return extendedPosition;
-}
-
 // src/dlmm/helpers/rebalance/rebalancePosition.ts
 import { SYSVAR_CLOCK_PUBKEY } from "@solana/web3.js";
 import BN12 from "bn.js";
@@ -23254,6 +23265,7 @@ export {
   getBinArrayKeysCoverage,
   getBinArrayLowerUpperBinId,
   getBinArraysRequiredByPositionRange,
+  getBinArraysRequiredByPositionRange2,
   getBinCount,
   getBinFromBinArray,
   getBinIdIndexInBinArray,