@meteora-ag/dlmm 1.9.12 → 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,381 +12418,96 @@ function decodeRewardPerTokenStored(bin) {
     "le",
     8
   );
-  const rewardPerTokenStored1 = new BN8(
+  const rewardPerTokenStored1 = new BN10(
     Buffer.concat([rewardPerTokenStored1Buf0, rewardPerTokenStored1Buf1]),
     "le"
-  );
-  return [rewardPerTokenStored0, rewardPerTokenStored1];
-}
-function getBinArrayInfoForNonContiguousBinIds(binIds, programId, lbPair) {
-  let binArrayBitmapExtension = programId;
-  const binArrayIndexes = /* @__PURE__ */ new Set();
-  for (const binId of binIds) {
-    const binArrayIndex = binIdToBinArrayIndex(new BN8(binId));
-    if (isOverflowDefaultBinArrayBitmap(binArrayIndex) && binArrayBitmapExtension.equals(programId)) {
-      binArrayBitmapExtension = deriveBinArrayBitmapExtension(
-        lbPair,
-        programId
-      )[0];
-    }
-    binArrayIndexes.add(binArrayIndex.toNumber());
-  }
-  const binArrayPubkeys = [...binArrayIndexes].map(
-    (idx) => deriveBinArray(lbPair, new BN8(idx), programId)[0]
-  );
-  const binArrayAccountMetas = binArrayPubkeys.map((pubkey) => {
-    return {
-      pubkey,
-      isSigner: false,
-      isWritable: true
-    };
-  });
-  return {
-    binArrayAccountMetas,
-    binArrayBitmapExtension,
-    binArrayIndexes: [...binArrayIndexes].map((idx) => new BN8(idx))
-  };
-}
-
-// src/dlmm/helpers/computeUnit.ts
-import {
-  ComputeBudgetProgram,
-  PublicKey as PublicKey6,
-  TransactionMessage,
-  VersionedTransaction
-} from "@solana/web3.js";
-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;
-  }
-};
-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
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
-    ...instructions
-  ];
-  const testTransaction = new VersionedTransaction(
-    new TransactionMessage({
-      instructions: testInstructions,
-      payerKey: payer,
-      // RecentBlockhash can by any public key during simulation
-      // since 'replaceRecentBlockhash' is set to 'true' below
-      recentBlockhash: PublicKey6.default.toString()
-    }).compileToV0Message(lookupTables)
-  );
-  const rpcResponse = await connection.simulateTransaction(testTransaction, {
-    replaceRecentBlockhash: true,
-    sigVerify: false,
-    commitment
-  });
-  if (rpcResponse?.value?.err) {
-    const logs = rpcResponse.value.logs?.join("\n  \u2022 ") || "No logs available";
-    throw new Error(
-      `Transaction simulation failed:
-  \u2022${logs}` + JSON.stringify(rpcResponse?.value?.err)
-    );
-  }
-  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;
+  );
+  return [rewardPerTokenStored0, rewardPerTokenStored1];
 }
-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;
+function getBinArrayInfoForNonContiguousBinIds(binIds, programId, lbPair) {
+  let binArrayBitmapExtension = programId;
+  const binArrayIndexes = /* @__PURE__ */ new Set();
+  for (const binId of binIds) {
+    const binArrayIndex = binIdToBinArrayIndex(new BN10(binId));
+    if (isOverflowDefaultBinArrayBitmap(binArrayIndex) && binArrayBitmapExtension.equals(programId)) {
+      binArrayBitmapExtension = deriveBinArrayBitmapExtension(
+        lbPair,
+        programId
+      )[0];
     }
+    binArrayIndexes.add(binArrayIndex.toNumber());
   }
-  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))
+  const binArrayPubkeys = [...binArrayIndexes].map(
+    (idx) => deriveBinArray(lbPair, new BN10(idx), programId)[0]
   );
+  const binArrayAccountMetas = binArrayPubkeys.map((pubkey) => {
+    return {
+      pubkey,
+      isSigner: false,
+      isWritable: true
+    };
+  });
+  return {
+    binArrayAccountMetas,
+    binArrayBitmapExtension,
+    binArrayIndexes: [...binArrayIndexes].map((idx) => new BN10(idx))
+  };
 }
-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;
+
+// src/dlmm/helpers/computeUnit.ts
+import {
+  ComputeBudgetProgram,
+  PublicKey as PublicKey6,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+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;
   }
-}
-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
+};
+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
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
+    ...instructions
+  ];
+  const testTransaction = new VersionedTransaction(
+    new TransactionMessage({
+      instructions: testInstructions,
+      payerKey: payer,
+      // RecentBlockhash can by any public key during simulation
+      // since 'replaceRecentBlockhash' is set to 'true' below
+      recentBlockhash: PublicKey6.default.toString()
+    }).compileToV0Message(lookupTables)
+  );
+  const rpcResponse = await connection.simulateTransaction(testTransaction, {
+    replaceRecentBlockhash: true,
+    sigVerify: false,
+    commitment
+  });
+  if (rpcResponse?.value?.err) {
+    const logs = rpcResponse.value.logs?.join("\n  \u2022 ") || "No logs available";
+    throw new Error(
+      `Transaction simulation failed:
+  \u2022${logs}` + JSON.stringify(rpcResponse?.value?.err)
     );
-    extendedPosition.push(decodedPositionBinData);
   }
-  return extendedPosition;
-}
+  return rpcResponse.value.unitsConsumed || null;
+};
 
 // src/dlmm/helpers/rebalance/rebalancePosition.ts
 import { SYSVAR_CLOCK_PUBKEY } from "@solana/web3.js";
@@ -16748,6 +16759,242 @@ var DLMM = class {
     }
     return positionsMap;
   }
+  /**
+   * The function `getPositionsByUserAndTokenAddress` retrieves all of a user's positions across every
+   * DLMM pool that includes the given token mint as either the X or Y token.
+   * @param {Connection} connection - The `connection` parameter is an instance of the `Connection`
+   * class, which represents the connection to the Solana blockchain.
+   * @param {PublicKey} userPubKey - The user's wallet public key.
+   * @param {PublicKey} tokenMint - The token mint used to filter pools. Only positions in pools whose
+   * `tokenXMint` or `tokenYMint` matches this mint are returned.
+   * @param {Opt} [opt] - An optional object that contains additional options for the function.
+   * @param {GetPositionsOpt} [getPositionsOpt] - Optional settings for chunked position fetching
+   * @returns The function `getPositionsByUserAndTokenAddress` returns a `Promise` that resolves to a
+   * `Map` object. The `Map` object contains key-value pairs, where the key is a string representing the
+   * LB Pair account, and the value is an object of PositionInfo. Only pools containing `tokenMint` are
+   * included.
+   */
+  static async getPositionsByUserAndTokenAddress(connection, userPubKey, tokenMint, opt, getPositionsOpt) {
+    const allPositions = await DLMM.getAllLbPairPositionsByUser(
+      connection,
+      userPubKey,
+      opt,
+      getPositionsOpt
+    );
+    const targetMint = tokenMint.toBase58();
+    const filteredPositions = /* @__PURE__ */ new Map();
+    for (const [lbPairKey, positionInfo] of allPositions) {
+      const tokenXMint = positionInfo.lbPair.tokenXMint.toBase58();
+      const tokenYMint = positionInfo.lbPair.tokenYMint.toBase58();
+      if (tokenXMint === targetMint || tokenYMint === targetMint) {
+        filteredPositions.set(lbPairKey, positionInfo);
+      }
+    }
+    return filteredPositions;
+  }
+  /**
+   * The function `getLimitOrdersByUserAndTokenAddress` retrieves all of a user's limit orders across
+   * every DLMM pool that includes the given token mint as either the X or Y token.
+   * @param {Connection} connection - The `connection` parameter is an instance of the `Connection`
+   * class, which represents the connection to the Solana blockchain.
+   * @param {PublicKey} userPubKey - The user's wallet public key.
+   * @param {PublicKey} tokenMint - The token mint used to filter pools. Only limit orders in pools
+   * whose `tokenXMint` or `tokenYMint` matches this mint are returned.
+   * @param {Opt} [opt] - An optional object that contains additional options for the function.
+   * @returns The function `getLimitOrdersByUserAndTokenAddress` returns a `Promise` that resolves to a
+   * `Map` object keyed by LB Pair account (base58), where each value is a `LimitOrderInfo` containing
+   * the LB pair state, token reserves, and the parsed limit orders for that pool.
+   */
+  static async getLimitOrdersByUserAndTokenAddress(connection, userPubKey, tokenMint, opt) {
+    const program = createProgram(connection, opt);
+    const limitOrderAccounts = await chunkedGetProgramAccounts(
+      program.provider.connection,
+      program.programId,
+      [limitOrderFilter(), limitOrderOwnerFilter(userPubKey)]
+    );
+    const limitOrderWrappers = limitOrderAccounts.map(
+      ({ pubkey, account }) => wrapLimitOrder(program, pubkey, account)
+    );
+    if (limitOrderWrappers.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const lbPairKeys = Array.from(
+      new Set(limitOrderWrappers.map((lo) => lo.lbPair().toBase58()))
+    ).map((key) => new PublicKey10(key));
+    const lbPairAccInfos = await chunkedGetMultipleAccountInfos(
+      connection,
+      lbPairKeys
+    );
+    const lbPairMap = /* @__PURE__ */ new Map();
+    lbPairKeys.forEach((lbPairPubkey, i) => {
+      const accInfo = lbPairAccInfos[i];
+      if (!accInfo) {
+        throw new Error(`LB Pair account ${lbPairPubkey.toBase58()} not found`);
+      }
+      lbPairMap.set(
+        lbPairPubkey.toBase58(),
+        decodeAccount(program, "lbPair", accInfo.data)
+      );
+    });
+    const targetMint = tokenMint.toBase58();
+    const matchingLbPairKeys = lbPairKeys.filter((lbPairPubkey) => {
+      const lbPairState = lbPairMap.get(lbPairPubkey.toBase58());
+      return lbPairState.tokenXMint.toBase58() === targetMint || lbPairState.tokenYMint.toBase58() === targetMint;
+    });
+    if (matchingLbPairKeys.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const matchingLbPairSet = new Set(
+      matchingLbPairKeys.map((key) => key.toBase58())
+    );
+    const matchingLimitOrders = limitOrderWrappers.filter(
+      (lo) => matchingLbPairSet.has(lo.lbPair().toBase58())
+    );
+    const reserveAndMintKeys = matchingLbPairKeys.map((lbPairPubkey) => {
+      const { reserveX, reserveY, tokenXMint, tokenYMint } = lbPairMap.get(
+        lbPairPubkey.toBase58()
+      );
+      return [reserveX, reserveY, tokenXMint, tokenYMint];
+    }).flat();
+    const binArrayPubkeySet = /* @__PURE__ */ new Set();
+    matchingLimitOrders.forEach((lo) => {
+      lo.getBinArrayKeysCoverage(program.programId).forEach((key) => {
+        binArrayPubkeySet.add(key.toBase58());
+      });
+    });
+    const binArrayKeys = Array.from(binArrayPubkeySet).map(
+      (key) => new PublicKey10(key)
+    );
+    const [clockAccInfo, ...rest] = await chunkedGetMultipleAccountInfos(
+      connection,
+      [SYSVAR_CLOCK_PUBKEY2, ...binArrayKeys, ...reserveAndMintKeys]
+    );
+    const binArraysAccInfo = rest.slice(0, binArrayKeys.length);
+    const reserveAndMintAccInfo = rest.slice(binArrayKeys.length);
+    const clock = ClockLayout.decode(clockAccInfo.data);
+    const binArrayMap = /* @__PURE__ */ new Map();
+    binArrayKeys.forEach((binArrayPubkey, i) => {
+      const accInfo = binArraysAccInfo[i];
+      if (accInfo) {
+        binArrayMap.set(
+          binArrayPubkey.toBase58(),
+          decodeAccount(program, "binArray", accInfo.data)
+        );
+      }
+    });
+    const seenMints = /* @__PURE__ */ new Set();
+    const mintsWithAccount = matchingLbPairKeys.flatMap((lbPairPubkey, idx) => {
+      const { tokenXMint, tokenYMint } = lbPairMap.get(
+        lbPairPubkey.toBase58()
+      );
+      const index = idx * 4;
+      return [
+        {
+          mintAddress: tokenXMint,
+          mintAccountInfo: reserveAndMintAccInfo[index + 2]
+        },
+        {
+          mintAddress: tokenYMint,
+          mintAccountInfo: reserveAndMintAccInfo[index + 3]
+        }
+      ];
+    }).filter(({ mintAddress, mintAccountInfo }) => {
+      if (!mintAccountInfo || seenMints.has(mintAddress.toBase58())) {
+        return false;
+      }
+      seenMints.add(mintAddress.toBase58());
+      return true;
+    });
+    const mintHookAccountsMap = await getMultipleMintsExtraAccountMetasForTransferHook(
+      connection,
+      mintsWithAccount
+    );
+    const lbPairTokenMap = /* @__PURE__ */ new Map();
+    matchingLbPairKeys.forEach((lbPairPubkey, idx) => {
+      const index = idx * 4;
+      const reserveXAccount = reserveAndMintAccInfo[index];
+      const reserveYAccount = reserveAndMintAccInfo[index + 1];
+      const mintXAccount = reserveAndMintAccInfo[index + 2];
+      const mintYAccount = reserveAndMintAccInfo[index + 3];
+      if (!reserveXAccount || !reserveYAccount) {
+        throw new Error(
+          `Reserve account for LB Pair ${lbPairPubkey.toBase58()} not found`
+        );
+      }
+      if (!mintXAccount || !mintYAccount) {
+        throw new Error(
+          `Mint account for LB Pair ${lbPairPubkey.toBase58()} not found`
+        );
+      }
+      const lbPairState = lbPairMap.get(lbPairPubkey.toBase58());
+      const reserveAccX = AccountLayout.decode(reserveXAccount.data);
+      const reserveAccY = AccountLayout.decode(reserveYAccount.data);
+      const mintX = unpackMint2(
+        reserveAccX.mint,
+        mintXAccount,
+        mintXAccount.owner
+      );
+      const mintY = unpackMint2(
+        reserveAccY.mint,
+        mintYAccount,
+        mintYAccount.owner
+      );
+      const { tokenXProgram, tokenYProgram } = getTokenProgramId(lbPairState);
+      const tokenX = {
+        publicKey: lbPairState.tokenXMint,
+        reserve: lbPairState.reserveX,
+        amount: reserveAccX.amount,
+        mint: mintX,
+        owner: tokenXProgram,
+        transferHookAccountMetas: mintHookAccountsMap.get(lbPairState.tokenXMint.toBase58()) ?? []
+      };
+      const tokenY = {
+        publicKey: lbPairState.tokenYMint,
+        reserve: lbPairState.reserveY,
+        amount: reserveAccY.amount,
+        mint: mintY,
+        owner: tokenYProgram,
+        transferHookAccountMetas: mintHookAccountsMap.get(lbPairState.tokenYMint.toBase58()) ?? []
+      };
+      lbPairTokenMap.set(lbPairPubkey.toBase58(), {
+        tokenX,
+        tokenY,
+        mintX,
+        mintY
+      });
+    });
+    const limitOrdersMap = /* @__PURE__ */ new Map();
+    for (const lo of matchingLimitOrders) {
+      const lbPairKey = lo.lbPair().toBase58();
+      const lbPairState = lbPairMap.get(lbPairKey);
+      const { tokenX, tokenY, mintX, mintY } = lbPairTokenMap.get(lbPairKey);
+      const parsedLo = lo.parseInfo(
+        program.programId,
+        lbPairState,
+        mintX,
+        mintY,
+        clock,
+        binArrayMap
+      );
+      const entry = {
+        publicKey: lo.address(),
+        limitOrderData: parsedLo
+      };
+      const existing = limitOrdersMap.get(lbPairKey);
+      if (existing) {
+        existing.limitOrders.push(entry);
+      } else {
+        limitOrdersMap.set(lbPairKey, {
+          publicKey: lo.lbPair(),
+          lbPair: lbPairState,
+          tokenX,
+          tokenY,
+          limitOrders: [entry]
+        });
+      }
+    }
+    return limitOrdersMap;
+  }
   static getPricePerLamport(tokenXDecimal, tokenYDecimal, price) {
     return new Decimal11(price).mul(new Decimal11(10 ** (tokenYDecimal - tokenXDecimal))).toString();
   }
@@ -23018,6 +23265,7 @@ export {
   getBinArrayKeysCoverage,
   getBinArrayLowerUpperBinId,
   getBinArraysRequiredByPositionRange,
+  getBinArraysRequiredByPositionRange2,
   getBinCount,
   getBinFromBinArray,
   getBinIdIndexInBinArray,