@meteora-ag/dlmm 1.6.0-rc.1 → 1.6.0-rc.11

package/dist/index.d.ts

@@ -10302,8 +10302,7 @@ declare class DLMM {
     quoteCreatePosition({ strategy }: TQuoteCreatePositionParams): Promise<{
         binArraysCount: number;
         binArrayCost: number;
-        positionCount: number;
-        positionCost: number;
+        transactionCount: number;
     }>;
     /**
      * Creates an empty position and initializes the corresponding bin arrays if needed.
@@ -10681,10 +10680,7 @@ declare class DLMM {
      *
      * @returns An object containing the instructions to initialize new bin arrays and the instruction to rebalance the position.
      */
-    rebalancePosition(rebalancePositionResponse: RebalancePositionResponse, maxActiveBinSlippage: BN$1, rentPayer?: PublicKey, slippage?: number): Promise<{
-        initBinArrayInstructions: TransactionInstruction[];
-        rebalancePositionInstruction: TransactionInstruction[];
-    }>;
+    rebalancePosition(rebalancePositionResponse: RebalancePositionResponse, maxActiveBinSlippage: BN$1, rentPayer?: PublicKey, slippage?: number): Promise<TransactionInstruction[][]>;
     /**
      * Create an extended empty position.
      *

package/dist/index.js

@@ -15107,16 +15107,14 @@ var DLMM = class {
       lowerBinArrayIndex.add(new (0, _anchor.BN)(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
+      transactionCount
     };
   }
   /**
@@ -18232,220 +18230,302 @@ var DLMM = class {
     const { lbPair, shouldClaimFee, shouldClaimReward, owner, address } = rebalancePosition;
     const { depositParams, withdrawParams } = simulationResult;
     const activeId = new (0, _anchor.BN)(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(_web3js.PublicKey.default)) {
-          const rewardTokenInfo = this.rewards[idx];
-          slices.push({
-            accountsType: {
-              transferHookMultiReward: {
-                0: idx
-              }
-            },
-            length: rewardTokenInfo.transferHookAccountMetas.length
-          });
-          transferHookAccounts.push(
-            ...rewardTokenInfo.transferHookAccountMetas
-          );
-          const userTokenRewardAddress = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-            reward.mint,
-            owner,
-            true,
-            rewardTokenInfo.owner
-          );
-          preInstructions.push(
-            _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-              owner,
-              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(_web3js.PublicKey.default)) {
+            const rewardTokenInfo = this.rewards[idx];
+            slices.push({
+              accountsType: {
+                transferHookMultiReward: {
+                  0: idx
+                }
+              },
+              length: rewardTokenInfo.transferHookAccountMetas.length
+            });
+            transferHookAccounts.push(
+              ...rewardTokenInfo.transferHookAccountMetas
+            );
+            const userTokenRewardAddress = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
               reward.mint,
+              owner,
+              true,
               rewardTokenInfo.owner
-            )
-          );
-          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(
+              _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+                owner,
+                userTokenRewardAddress,
+                owner,
+                reward.mint,
+                rewardTokenInfo.owner
+              )
+            );
+            const rewardVault = {
+              pubkey: reward.vault,
+              isSigner: false,
+              isWritable: true
+            };
+            const userTokenReward = {
+              pubkey: userTokenRewardAddress,
+              isSigner: false,
+              isWritable: true
+            };
+            const rewardMint = {
+              pubkey: reward.mint,
+              isSigner: false,
+              isWritable: false
+            };
+            const rewardTokenProgram = {
+              pubkey: rewardTokenInfo.owner,
+              isSigner: false,
+              isWritable: false
+            };
+            harvestRewardRemainingAccountMetas.push(
+              rewardVault,
+              userTokenReward,
+              rewardMint,
+              rewardTokenProgram
+            );
+          }
         }
       }
-    }
-    const 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(_web3js.PublicKey.default)) {
-      const bitmapAccount = await this.program.provider.connection.getAccountInfo(binArrayBitmap);
-      if (!bitmapAccount) {
-        const initBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
-          binArrayBitmapExtension: binArrayBitmap,
-          funder: owner,
-          lbPair: this.pubkey
-        }).preInstructions([
-          _web3js.ComputeBudgetProgram.setComputeUnitLimit({
-            units: DEFAULT_INIT_BIN_ARRAY_CU
-          })
-        ]).instruction();
-        preInstructions.push(initBitmapExtensionIx);
+      if (!binArrayBitmap.equals(_web3js.PublicKey.default)) {
+        const bitmapAccount = await this.program.provider.connection.getAccountInfo(binArrayBitmap);
+        if (!bitmapAccount) {
+          const initBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
+            binArrayBitmapExtension: binArrayBitmap,
+            funder: owner,
+            lbPair: this.pubkey
+          }).preInstructions([
+            _web3js.ComputeBudgetProgram.setComputeUnitLimit({
+              units: DEFAULT_INIT_BIN_ARRAY_CU
+            })
+          ]).instruction();
+          preInstructions.push(initBitmapExtensionIx);
+        }
       }
-    }
-    const userTokenX = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-      this.tokenX.publicKey,
-      owner,
-      true,
-      this.tokenX.owner
-    );
-    const userTokenY = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
-      this.tokenY.publicKey,
-      owner,
-      true,
-      this.tokenY.owner
-    );
-    preInstructions.push(
-      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+      const [
+        { ataPubKey: userTokenX, ix: createUserTokenXIx },
+        { ataPubKey: userTokenY, ix: createUserTokenYIx }
+      ] = await Promise.all([
+        getOrCreateATAInstruction(
+          this.program.provider.connection,
+          this.tokenX.publicKey,
+          owner,
+          this.tokenX.owner
+        ),
+        getOrCreateATAInstruction(
+          this.program.provider.connection,
+          this.tokenY.publicKey,
+          owner,
+          this.tokenY.owner
+        )
+      ]);
+      createUserTokenXIx && preInstructions.push(createUserTokenXIx);
+      createUserTokenYIx && preInstructions.push(createUserTokenYIx);
+      slippage = capSlippagePercentage(slippage);
+      const applySlippageMaxAmount = (amount, slippage2) => {
+        return slippage2 == 100 ? U64_MAX : amount.muln(100 + slippage2).divn(100);
+      };
+      const applySlippageMinAmount = (amount, slippage2) => {
+        return amount.muln(100 - slippage2).divn(100);
+      };
+      const maxDepositXAmount = applySlippageMaxAmount(
+        simulationResult.actualAmountXDeposited,
+        slippage
+      );
+      const maxDepositYAmount = applySlippageMaxAmount(
+        simulationResult.actualAmountYDeposited,
+        slippage
+      );
+      const minWithdrawXAmount = applySlippageMinAmount(
+        simulationResult.actualAmountXWithdrawn,
+        slippage
+      );
+      const minWithdrawYAmount = applySlippageMinAmount(
+        simulationResult.actualAmountYWithdrawn,
+        slippage
+      );
+      const postInstructions = [];
+      if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountXDeposited.gtn(0)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          userTokenX,
+          BigInt(simulationResult.actualAmountXDeposited.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT) && simulationResult.actualAmountYDeposited.gtn(0)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          userTokenY,
+          BigInt(simulationResult.actualAmountYDeposited.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (this.tokenX.publicKey.equals(_spltoken.NATIVE_MINT) || this.tokenY.publicKey.equals(_spltoken.NATIVE_MINT)) {
+        const closeWrappedSOLIx = await unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const instruction = await this.program.methods.rebalanceLiquidity(
+        {
+          adds: 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(
-      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-        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
-    );
-    const instruction = await this.program.methods.rebalanceLiquidity(
-      {
-        adds: depositParams,
-        removes: withdrawParams,
-        activeId: activeId.toNumber(),
-        shouldClaimFee,
-        shouldClaimReward,
-        maxActiveBinSlippage: maxActiveBinSlippage.toNumber(),
-        maxDepositXAmount,
-        maxDepositYAmount,
-        minWithdrawXAmount,
-        minWithdrawYAmount,
-        padding: Array(32).fill(0)
-      },
-      {
-        slices
-      }
-    ).accountsPartial({
-      lbPair: this.pubkey,
-      binArrayBitmapExtension: binArrayBitmap,
-      position: address,
-      owner,
-      userTokenX,
-      userTokenY,
-      reserveX: this.lbPair.reserveX,
-      reserveY: this.lbPair.reserveY,
-      tokenXMint: this.tokenX.publicKey,
-      tokenYMint: this.tokenY.publicKey,
-      tokenXProgram: this.tokenX.owner,
-      tokenYProgram: this.tokenY.owner,
-      memoProgram: MEMO_PROGRAM_ID,
-      rentPayer: _nullishCoalesce(rentPayer, () => ( owner))
-    }).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
-    );
-    const rebalancePositionInstruction = [setCUIX, instruction];
-    return {
-      initBinArrayInstructions,
-      rebalancePositionInstruction
-    };
+        reserveX: this.lbPair.reserveX,
+        reserveY: this.lbPair.reserveY,
+        tokenXMint: this.tokenX.publicKey,
+        tokenYMint: this.tokenY.publicKey,
+        tokenXProgram: this.tokenX.owner,
+        tokenYProgram: this.tokenY.owner,
+        memoProgram: MEMO_PROGRAM_ID,
+        rentPayer: _nullishCoalesce(rentPayer, () => ( owner))
+      }).remainingAccounts(transferHookAccounts).remainingAccounts(
+        binArrayPublicKeys.map((pubkey) => {
+          return {
+            pubkey,
+            isSigner: false,
+            isWritable: true
+          };
+        })
+      ).instruction();
+      const setCUIX = await getEstimatedComputeUnitIxWithBuffer(
+        this.program.provider.connection,
+        [instruction],
+        owner
+      );
+      const rebalancePositionInstruction = [
+        setCUIX,
+        ...initBinArrayInstructions,
+        ...preInstructions,
+        instruction,
+        ...postInstructions
+      ];
+      allInstructions.push(rebalancePositionInstruction);
+    }
+    return allInstructions;
   }
   /**
    * Create an extended empty position.
@@ -18471,7 +18551,8 @@ var DLMM = class {
     );
     const latestBlockhashInfo = await this.program.provider.connection.getLatestBlockhash();
     const tx = new (0, _web3js.Transaction)({
-      ...latestBlockhashInfo
+      ...latestBlockhashInfo,
+      feePayer: owner
     }).add(...ixs);
     return tx;
   }