@meteora-ag/dlmm 1.6.0-rc.0 → 1.6.0-rc.10

package/dist/index.mjs

@@ -12,7 +12,6 @@ import {
 } from "@solana/spl-token";
 import {
   ComputeBudgetProgram as ComputeBudgetProgram3,
-  Keypair as Keypair2,
   LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2,
   PublicKey as PublicKey10,
   SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2,
@@ -12180,20 +12179,6 @@ function isPositionNoFee(position) {
 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) {
   const chunkedBinRange = [];
   let startBinId = minBinId;
@@ -15122,78 +15107,14 @@ var DLMM = class {
       lowerBinArrayIndex.add(new BN21(1))
     );
     const binArraysCount = (await this.binArraysToBeCreate(lowerBinArrayIndex, upperBinArrayIndex)).length;
-    const positionCount = Math.ceil(
-      (maxBinId - minBinId + 1) / Number(MAX_BINS_PER_POSITION)
+    const transactionCount = Math.ceil(
+      (maxBinId - minBinId + 1) / DEFAULT_BIN_PER_POSITION.toNumber()
     );
     const binArrayCost = binArraysCount * BIN_ARRAY_FEE;
-    const positionCost = positionCount * POSITION_FEE;
     return {
       binArraysCount,
       binArrayCost,
-      positionCount,
-      positionCost
-    };
-  }
-  /**
-   * Estimates the cost to create a new position based on the given strategy.
-   *
-   * This function calculates the costs associated with creating bin arrays, positions
-   * and extending positions for a specified range of bins.
-   *
-   * @param {TQuoteCreatePositionParams} param0 - The settings of the requested new position,
-   * including the strategy with minimum and maximum bin IDs.
-   * @returns An object containing:
-   *   - binArraysCount: The number of bin arrays required.
-   *   - binArrayCost: The estimated cost for creating bin arrays.
-   *   - positionCount: The number of positions required.
-   *   - positionCost: The fee cost for creating positions.
-   *   - positionExtendCost: The rent cost in lamports for extending positions.
-   */
-  async quoteCreateMultiplePositions({
-    strategy
-  }) {
-    const { minBinId, maxBinId } = strategy;
-    const minBinIdBN = new BN21(minBinId);
-    const maxBinIdBN = new BN21(maxBinId);
-    const lowerBinArrayIndex = binIdToBinArrayIndex(minBinIdBN);
-    const upperBinArrayIndex = binIdToBinArrayIndex(maxBinIdBN);
-    const binArraysCount = (await this.binArraysToBeCreate(lowerBinArrayIndex, upperBinArrayIndex)).length;
-    const binArrayCost = new Decimal7(binArraysCount).mul(
-      new Decimal7(BIN_ARRAY_FEE)
-    );
-    let positionCost = new Decimal7(0);
-    let positionExtendCost = new Decimal7(0);
-    const chunkedPositionBinRange = chunkBinRangeIntoExtendedPositions(
-      minBinId,
-      maxBinId
-    );
-    const positionCount = chunkedPositionBinRange.length;
-    for (const { lowerBinId, upperBinId } of chunkedPositionBinRange) {
-      positionCost = positionCost.add(new Decimal7(POSITION_FEE));
-      const lowerBinIdBN = new BN21(lowerBinId);
-      const upperBinIdBN = new BN21(upperBinId);
-      const extendedBinCount = getExtendedPositionBinCount(
-        lowerBinIdBN,
-        upperBinIdBN
-      );
-      const upperBinIdBeforeExtend = upperBinIdBN.sub(extendedBinCount);
-      positionExtendCost = positionExtendCost.add(
-        await getPositionExpandRentExemption(
-          lowerBinIdBN,
-          upperBinIdBeforeExtend,
-          this.program.provider.connection,
-          extendedBinCount
-        ).then(
-          (lamports) => new Decimal7(lamports).div(new Decimal7(LAMPORTS_PER_SOL2))
-        )
-      );
-    }
-    return {
-      binArraysCount,
-      binArrayCost,
-      positionCount,
-      positionCost,
-      positionExtendCost
+      transactionCount
     };
   }
   /**
@@ -15234,84 +15155,6 @@ var DLMM = class {
       feePayer: user
     }).add(setCUIx, ...instructions);
   }
-  /**
-   * Creates multiple empty positions for a user in specified bin ranges with necessary bin arrays.
-   *
-   * @param {number} minBinId - The minimum bin ID for the positions.
-   * @param {number} maxBinId - The maximum bin ID for the positions.
-   * @param {PublicKey} user - The public key of the user for whom the positions are created.
-   *
-   * @returns An object containing arrays of transactions for initializing positions, extending positions and initialzing bin arrays.
-   */
-  async createMultipleEmptyPositions({
-    minBinId,
-    maxBinId,
-    user
-  }) {
-    const chunkedBinRange = chunkBinRangeIntoExtendedPositions(
-      minBinId,
-      maxBinId
-    );
-    const positionCount = chunkedBinRange.length;
-    const positionKeypairs = [];
-    const initPositionIxs = [];
-    const initBinArrayIxs = [];
-    const binArrayIndexSet = /* @__PURE__ */ new Set();
-    for (let i = 0; i < positionCount; i++) {
-      const positionKeypair = Keypair2.generate();
-      positionKeypairs.push(positionKeypair);
-      const { lowerBinId, upperBinId } = chunkedBinRange[i];
-      let width = upperBinId - lowerBinId + 1;
-      width = Math.min(width, DEFAULT_BIN_PER_POSITION.toNumber());
-      const initPositionIx = await this.createInitAndExtendPositionIx(
-        lowerBinId,
-        upperBinId,
-        width,
-        user,
-        positionKeypair.publicKey
-      );
-      initPositionIxs.push(initPositionIx);
-      const binArrayIndexes = getBinArrayIndexesCoverage(
-        new BN21(lowerBinId),
-        new BN21(upperBinId)
-      ).filter((idx) => !binArrayIndexSet.has(idx.toNumber()));
-      const createBinArrayIxs = await this.createBinArraysIfNeeded(
-        binArrayIndexes,
-        user
-      ).then(
-        (ixs) => ixs.map((ix) => [
-          ComputeBudgetProgram3.setComputeUnitLimit({
-            units: DEFAULT_INIT_BIN_ARRAY_CU
-          }),
-          ix
-        ])
-      );
-      binArrayIndexes.map((idx) => {
-        binArrayIndexSet.add(idx.toNumber());
-      });
-      initBinArrayIxs.push(...createBinArrayIxs);
-    }
-    const { blockhash, lastValidBlockHeight } = await this.program.provider.connection.getLatestBlockhash("confirmed");
-    const initPositionTxs = initPositionIxs.map((ix) => {
-      return new Transaction({
-        blockhash,
-        lastValidBlockHeight,
-        feePayer: user
-      }).add(...ix);
-    });
-    const initBinArrayTxs = initBinArrayIxs.map((ix) => {
-      return new Transaction({
-        blockhash,
-        lastValidBlockHeight,
-        feePayer: user
-      }).add(...ix);
-    });
-    return {
-      positionKeypairs,
-      initPositionTxs,
-      initBinArrayTxs
-    };
-  }
   /**
    * The function `getPosition` retrieves position information for a given public key and processes it
    * using various data to return a `LbPosition` object.
@@ -18387,220 +18230,334 @@ var DLMM = class {
     const { lbPair, shouldClaimFee, shouldClaimReward, owner, address } = rebalancePosition;
     const { depositParams, withdrawParams } = simulationResult;
     const activeId = new BN21(lbPair.activeId);
-    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(PublicKey10.default)) {
-          const rewardTokenInfo = this.rewards[idx];
-          slices.push({
-            accountsType: {
-              transferHookMultiReward: {
-                0: idx
-              }
-            },
-            length: rewardTokenInfo.transferHookAccountMetas.length
-          });
-          transferHookAccounts.push(
-            ...rewardTokenInfo.transferHookAccountMetas
-          );
-          const userTokenRewardAddress = getAssociatedTokenAddressSync2(
-            reward.mint,
-            owner,
-            true,
-            rewardTokenInfo.owner
-          );
-          preInstructions.push(
-            createAssociatedTokenAccountIdempotentInstruction2(
-              owner,
-              userTokenRewardAddress,
-              owner,
+    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(PublicKey10.default)) {
+            const rewardTokenInfo = this.rewards[idx];
+            slices.push({
+              accountsType: {
+                transferHookMultiReward: {
+                  0: idx
+                }
+              },
+              length: rewardTokenInfo.transferHookAccountMetas.length
+            });
+            transferHookAccounts.push(
+              ...rewardTokenInfo.transferHookAccountMetas
+            );
+            const userTokenRewardAddress = getAssociatedTokenAddressSync2(
               reward.mint,
+              owner,
+              true,
               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
-          );
+            );
+            preInstructions.push(
+              createAssociatedTokenAccountIdempotentInstruction2(
+                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 initBinArrayInstructions = [];
-    const { binArrayBitmap, binArrayIndexes } = getRebalanceBinArrayIndexesAndBitmapCoverage(
-      depositParams,
-      withdrawParams,
-      activeId.toNumber(),
-      this.pubkey,
-      this.program.programId
-    );
-    const binArrayPublicKeys = binArrayIndexes.map((index) => {
-      const [binArrayPubkey] = deriveBinArray(
+      const initBinArrayInstructions = [];
+      const { binArrayBitmap, binArrayIndexes } = getRebalanceBinArrayIndexesAndBitmapCoverage(
+        chunkedDepositParams,
+        chunkedWithdrawParams,
+        activeId.toNumber(),
         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);
+      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(PublicKey10.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([
-          ComputeBudgetProgram3.setComputeUnitLimit({
-            units: DEFAULT_INIT_BIN_ARRAY_CU
-          })
-        ]).instruction();
-        preInstructions.push(initBitmapExtensionIx);
+      if (!binArrayBitmap.equals(PublicKey10.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([
+            ComputeBudgetProgram3.setComputeUnitLimit({
+              units: DEFAULT_INIT_BIN_ARRAY_CU
+            })
+          ]).instruction();
+          preInstructions.push(initBitmapExtensionIx);
+        }
       }
-    }
-    const userTokenX = getAssociatedTokenAddressSync2(
-      this.tokenX.publicKey,
-      owner,
-      true,
-      this.tokenX.owner
-    );
-    const userTokenY = getAssociatedTokenAddressSync2(
-      this.tokenY.publicKey,
-      owner,
-      true,
-      this.tokenY.owner
-    );
-    preInstructions.push(
-      createAssociatedTokenAccountIdempotentInstruction2(
+      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(NATIVE_MINT2) && simulationResult.actualAmountXDeposited.gtn(0)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          userTokenX,
+          BigInt(simulationResult.actualAmountXDeposited.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (this.tokenY.publicKey.equals(NATIVE_MINT2) && simulationResult.actualAmountYDeposited.gtn(0)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          userTokenY,
+          BigInt(simulationResult.actualAmountYDeposited.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (this.tokenX.publicKey.equals(NATIVE_MINT2) || this.tokenY.publicKey.equals(NATIVE_MINT2)) {
+        const closeWrappedSOLIx = await unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      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,
         owner,
         userTokenX,
-        owner,
-        this.tokenX.publicKey,
-        this.tokenX.owner
-      )
-    );
-    preInstructions.push(
-      createAssociatedTokenAccountIdempotentInstruction2(
-        owner,
         userTokenY,
-        owner,
-        this.tokenY.publicKey,
-        this.tokenY.owner
-      )
-    );
-    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
+        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: 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
+      ];
+      allInstructions.push({
+        initBinArrayInstructions,
+        rebalancePositionInstruction,
+        chunk
+      });
+    }
+    return allInstructions;
+  }
+  /**
+   * Create an extended empty position.
+   *
+   * @param lowerBinid The lowest bin of the position.
+   * @param upperBinId The highest bin of the position.
+   * @param position The public key of the position.
+   * @param owner The owner of the position.
+   * @returns The instructions to create the extended empty position.
+   */
+  async createExtendedEmptyPosition(lowerBinid, upperBinId, position, owner) {
+    const positionWidth = upperBinId - lowerBinid + 1;
+    const basePositionWidth = Math.min(
+      positionWidth,
+      DEFAULT_BIN_PER_POSITION.toNumber()
     );
-    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,
+    const ixs = await this.createInitAndExtendPositionIx(
+      lowerBinid,
+      upperBinId,
+      basePositionWidth,
       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: rentPayer ?? owner
-    }).preInstructions(preInstructions).remainingAccounts(transferHookAccounts).remainingAccounts(
-      binArrayPublicKeys.map((pubkey) => {
-        return {
-          pubkey,
-          isSigner: false,
-          isWritable: true
-        };
-      })
-    ).instruction();
-    const setCUIX = await getEstimatedComputeUnitIxWithBuffer(
-      this.program.provider.connection,
-      [instruction],
-      owner
+      position
     );
-    const rebalancePositionInstruction = [setCUIX, instruction];
-    return {
-      initBinArrayInstructions,
-      rebalancePositionInstruction
-    };
+    const latestBlockhashInfo = await this.program.provider.connection.getLatestBlockhash();
+    const tx = new Transaction({
+      ...latestBlockhashInfo,
+      feePayer: owner
+    }).add(...ixs);
+    return tx;
   }
   async createInitAndExtendPositionIx(lowerBinId, upperBinId, basePositionWidth, user, position) {
     const createPositionIx = await this.program.methods.initializePosition(lowerBinId, basePositionWidth).accountsPartial({