@meteora-ag/dlmm 1.9.12 → 1.9.13

package/dist/index.mjs

@@ -16748,6 +16748,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();
   }