@meteora-ag/dlmm 1.9.2 → 1.9.3

package/dist/index.mjs

@@ -15649,6 +15649,71 @@ async function chunkedGetMultipleAccountInfos(connection, pks, chunkSize = 100)
   )).flat();
   return accountInfos;
 }
+async function chunkedGetProgramAccounts(connection, programId, filters, chunkSize = 100, onChunkFetched, isParallelExecution = false) {
+  const accountsWithoutData = await connection.getProgramAccounts(programId, {
+    filters,
+    dataSlice: { offset: 0, length: 0 }
+  });
+  if (accountsWithoutData.length === 0) {
+    return [];
+  }
+  const pubkeys = accountsWithoutData.map((account) => account.pubkey);
+  const totalAccounts = pubkeys.length;
+  const chunkedPks = chunks(pubkeys, chunkSize);
+  const totalChunks = chunkedPks.length;
+  let chunksLoaded = 0;
+  let accountsLoaded = 0;
+  const chunkResults = new Array(totalChunks);
+  const processChunk = async (chunk, chunkIndex) => {
+    const chunkAccountInfos = await connection.getMultipleAccountsInfo(chunk);
+    chunkResults[chunkIndex] = chunkAccountInfos;
+    if (onChunkFetched) {
+      const chunkAccounts = [];
+      const startIdx = chunkIndex * chunkSize;
+      for (let i = 0; i < chunkAccountInfos.length; i++) {
+        const accountInfo = chunkAccountInfos[i];
+        if (accountInfo) {
+          chunkAccounts.push({
+            pubkey: pubkeys[startIdx + i],
+            account: accountInfo
+          });
+        }
+      }
+      chunksLoaded++;
+      accountsLoaded += chunkAccounts.length;
+      onChunkFetched(chunkAccounts, {
+        chunksLoaded,
+        totalChunks,
+        accountsLoaded,
+        totalAccounts
+      });
+    }
+  };
+  if (isParallelExecution) {
+    await Promise.all(
+      chunkedPks.map((chunk, chunkIndex) => processChunk(chunk, chunkIndex))
+    );
+  } else {
+    for (let chunkIndex = 0; chunkIndex < chunkedPks.length; chunkIndex++) {
+      await processChunk(chunkedPks[chunkIndex], chunkIndex);
+    }
+  }
+  const result = [];
+  for (let chunkIndex = 0; chunkIndex < chunkResults.length; chunkIndex++) {
+    const chunkAccountInfos = chunkResults[chunkIndex];
+    const startIdx = chunkIndex * chunkSize;
+    for (let i = 0; i < chunkAccountInfos.length; i++) {
+      const accountInfo = chunkAccountInfos[i];
+      if (accountInfo) {
+        result.push({
+          pubkey: pubkeys[startIdx + i],
+          account: accountInfo
+        });
+      }
+    }
+  }
+  return result;
+}
 var getEstimatedComputeUnitUsageWithBuffer = async (connection, instructions, feePayer, buffer, altAddress) => {
   if (!buffer) {
     buffer = 0.1;
@@ -16669,17 +16734,20 @@ var DLMM = class {
    * class, which represents the connection to the Solana blockchain.
    * @param {PublicKey} userPubKey - The user's wallet public key.
    * @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 `getAllLbPairPositionsByUser` 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
    */
-  static async getAllLbPairPositionsByUser(connection, userPubKey, opt) {
+  static async getAllLbPairPositionsByUser(connection, userPubKey, opt, getPositionsOpt) {
     const program = createProgram(connection, opt);
-    const positionsV2 = await program.provider.connection.getProgramAccounts(
+    const positionsV2 = await chunkedGetProgramAccounts(
+      program.provider.connection,
       program.programId,
-      {
-        filters: [positionV2Filter(), positionOwnerFilter(userPubKey)]
-      }
+      [positionV2Filter(), positionOwnerFilter(userPubKey)],
+      getPositionsOpt?.chunkSize,
+      getPositionsOpt?.onChunkFetched,
+      getPositionsOpt?.isParallelExecution
     );
     const positionWrappers = [
       ...positionsV2.map((p) => wrapPosition(program, p.pubkey, p.account))
@@ -16873,16 +16941,19 @@ var DLMM = class {
    * The function `getLbPairLockInfo` retrieves all pair positions that has locked liquidity.
    * @param {number} [lockDurationOpt] - An optional value indicating the minimum position lock duration that the function should return.
    * Depending on the lbPair activationType, the param should be a number of seconds or a number of slots.
+   * @param {GetPositionsOpt} [getPositionsOpt] - Optional settings for chunked position fetching
    * @returns The function `getLbPairLockInfo` returns a `Promise` that resolves to a `PairLockInfo`
    * object. The `PairLockInfo` object contains an array of `PositionLockInfo` objects.
    */
-  async getLbPairLockInfo(lockDurationOpt) {
+  async getLbPairLockInfo(lockDurationOpt, getPositionsOpt) {
     const lockDuration = lockDurationOpt | 0;
-    const positionAccounts = await this.program.provider.connection.getProgramAccounts(
+    const positionAccounts = await chunkedGetProgramAccounts(
+      this.program.provider.connection,
       this.program.programId,
-      {
-        filters: [positionLbPairFilter(this.pubkey)]
-      }
+      [positionLbPairFilter(this.pubkey)],
+      getPositionsOpt?.chunkSize,
+      getPositionsOpt?.onChunkFetched,
+      getPositionsOpt?.isParallelExecution
     );
     const lbPairPositions = positionAccounts.map((acc) => {
       return wrapPosition(this.program, acc.pubkey, acc.account);
@@ -17776,24 +17847,27 @@ var DLMM = class {
    * `PublicKey`. It represents the public key of a user. If no `userPubKey` is provided, the function
    * will return an object with an empty `userPositions` array and the active bin information obtained
    * from the `getActive
+   * @param {GetPositionsOpt} [getPositionsOpt] - Optional settings for chunked position fetching
    * @returns The function `getPositionsByUserAndLbPair` returns a Promise that resolves to an object
    * with two properties:
    *    - "activeBin" which is an object with two properties: "binId" and "price". The value of "binId"
    *     is the active bin ID of the lbPair, and the value of "price" is the price of the active bin.
    *   - "userPositions" which is an array of Position objects.
    */
-  async getPositionsByUserAndLbPair(userPubKey) {
+  async getPositionsByUserAndLbPair(userPubKey, getPositionsOpt) {
     const promiseResults = await Promise.all([
       this.getActiveBin(),
-      userPubKey && this.program.provider.connection.getProgramAccounts(
+      userPubKey && chunkedGetProgramAccounts(
+        this.program.provider.connection,
         this.program.programId,
-        {
-          filters: [
-            positionV2Filter(),
-            positionOwnerFilter(userPubKey),
-            positionLbPairFilter(this.pubkey)
-          ]
-        }
+        [
+          positionV2Filter(),
+          positionOwnerFilter(userPubKey),
+          positionLbPairFilter(this.pubkey)
+        ],
+        getPositionsOpt?.chunkSize,
+        getPositionsOpt?.onChunkFetched,
+        getPositionsOpt?.isParallelExecution
       )
     ]);
     const [activeBin, positionsV2] = promiseResults;
@@ -22300,6 +22374,7 @@ export {
   chunkedFetchMultipleBinArrayBitmapExtensionAccount,
   chunkedFetchMultiplePoolAccount,
   chunkedGetMultipleAccountInfos,
+  chunkedGetProgramAccounts,
   chunks,
   computeFee,
   computeFeeFromAmount,