@meteora-ag/dlmm 1.9.12 → 1.9.13

package/README.md

@@ -44,7 +44,7 @@ const dlmmPool = await DLMM.createMultiple(connection, [USDC_USDT_POOL, ...]);
 const activeBin = await dlmmPool.getActiveBin();
 const activeBinPriceLamport = activeBin.price;
 const activeBinPricePerToken = dlmmPool.fromPricePerLamport(
-  Number(activeBin.price)
+  Number(activeBin.price),
 );
 ```
 
@@ -64,7 +64,7 @@ const totalYAmount = autoFillYByStrategy(
   activeBin.yAmount,
   minBinId,
   maxBinId,
-  StrategyType.Spot // can be StrategyType.Spot, StrategyType.BidAsk, StrategyType.Curve
+  StrategyType.Spot, // can be StrategyType.Spot, StrategyType.BidAsk, StrategyType.Curve
 );
 const newBalancePosition = new Keypair();
 
@@ -86,7 +86,7 @@ try {
   const createBalancePositionTxHash = await sendAndConfirmTransaction(
     connection,
     createPositionTx,
-    [user, newBalancePosition]
+    [user, newBalancePosition],
   );
 } catch (error) {}
 ```
@@ -120,7 +120,7 @@ try {
   const createBalancePositionTxHash = await sendAndConfirmTransaction(
     connection,
     createPositionTx,
-    [user, newImbalancePosition]
+    [user, newImbalancePosition],
   );
 } catch (error) {}
 ```
@@ -154,7 +154,7 @@ try {
   const createOneSidePositionTxHash = await sendAndConfirmTransaction(
     connection,
     createPositionTx,
-    [user, newOneSidePosition]
+    [user, newOneSidePosition],
   );
 } catch (error) {}
 ```
@@ -163,7 +163,7 @@ try {
 
 ```ts
 const { userPositions } = await dlmmPool.getPositionsByUserAndLbPair(
-  user.publicKey
+  user.publicKey,
 );
 const binData = userPositions[0].positionData.positionBinData;
 ```
@@ -184,7 +184,7 @@ const totalYAmount = autoFillYByStrategy(
   activeBin.yAmount,
   minBinId,
   maxBinId,
-  StrategyType.Spot // can be StrategyType.Spot, StrategyType.BidAsk, StrategyType.Curve
+  StrategyType.Spot, // can be StrategyType.Spot, StrategyType.BidAsk, StrategyType.Curve
 );
 
 // Add Liquidity to existing position
@@ -204,7 +204,7 @@ try {
   const addLiquidityTxHash = await sendAndConfirmTransaction(
     connection,
     addLiquidityTx,
-    [user]
+    [user],
   );
 } catch (error) {}
 ```
@@ -213,11 +213,11 @@ try {
 
 ```ts
 const userPosition = userPositions.find(({ publicKey }) =>
-  publicKey.equals(newBalancePosition.publicKey)
+  publicKey.equals(newBalancePosition.publicKey),
 );
 // Remove Liquidity
 const binIdsToRemove = userPosition.positionData.positionBinData.map(
-  (bin) => bin.binId
+  (bin) => bin.binId,
 );
 const removeLiquidityTx = await dlmmPool.removeLiquidity({
   position: userPosition.publicKey,
@@ -225,7 +225,7 @@ const removeLiquidityTx = await dlmmPool.removeLiquidity({
   fromBinId: binIdsToRemove[0],
   toBinId: binIdsToRemove[binIdsToRemove.length - 1],
   liquiditiesBpsToRemove: new Array(binIdsToRemove.length).fill(
-    new BN(100 * 100)
+    new BN(100 * 100),
   ), // 100% (range from 0 to 100)
   shouldClaimAndClose: true, // should claim swap fee and close position together
 });
@@ -238,7 +238,7 @@ try {
       connection,
       tx,
       [user],
-      { skipPreflight: false, preflightCommitment: "singleGossip" }
+      { skipPreflight: false, preflightCommitment: "singleGossip" },
     );
   }
 } catch (error) {}
@@ -258,7 +258,7 @@ async function claimFee(dlmmPool: DLMM) {
       const claimFeeTxHash = await sendAndConfirmTransaction(
         connection,
         claimFeeTx,
-        [user]
+        [user],
       );
     }
   } catch (error) {}
@@ -278,7 +278,7 @@ try {
     connection,
     closePositionTx,
     [user],
-    { skipPreflight: false, preflightCommitment: "singleGossip" }
+    { skipPreflight: false, preflightCommitment: "singleGossip" },
   );
 } catch (error) {}
 ```
@@ -295,7 +295,7 @@ const swapQuote = await dlmmPool.swapQuote(
   swapAmount,
   swapYtoX,
   new BN(1),
-  binArrays
+  binArrays,
 );
 
 // Swap
@@ -318,15 +318,17 @@ try {
 
 ## Static functions
 
-| Function                      | Description                                                                        | Return                               |
-| ----------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------ |
-| `create`                      | Given the DLMM address, create an instance to access the state and functions       | `Promise<DLMM>`                      |
-| `createMultiple`              | Given a list of DLMM addresses, create instances to access the state and functions | `Promise<Array<DLMM>>`               |
-| `getAllPresetParameters`      | Get all the preset params (use to create DLMM pool)                                | `Promise<PresetParams>`              |
-| `createPermissionLbPair`      | Create DLMM Pool                                                                   | `Promise<Transcation>`               |
-| `getClaimableLMReward`        | Get Claimable LM reward for a position                                             | `Promise<LMRewards>`                 |
-| `getClaimableSwapFee`         | Get Claimable Swap Fee for a position                                              | `Promise<SwapFee>`                   |
-| `getAllLbPairPositionsByUser` | Get user's all positions for all DLMM pools                                        | `Promise<Map<string, PositionInfo>>` |
+| Function                            | Description                                                                        | Return                               |
+| ----------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------ |
+| `create`                            | Given the DLMM address, create an instance to access the state and functions       | `Promise<DLMM>`                      |
+| `createMultiple`                    | Given a list of DLMM addresses, create instances to access the state and functions | `Promise<Array<DLMM>>`               |
+| `getAllPresetParameters`            | Get all the preset params (use to create DLMM pool)                                | `Promise<PresetParams>`              |
+| `createPermissionLbPair`            | Create DLMM Pool                                                                   | `Promise<Transcation>`               |
+| `getClaimableLMReward`              | Get Claimable LM reward for a position                                             | `Promise<LMRewards>`                 |
+| `getClaimableSwapFee`               | Get Claimable Swap Fee for a position                                              | `Promise<SwapFee>`                   |
+| `getAllLbPairPositionsByUser`       | Get user's all positions for all DLMM pools                                        | `Promise<Map<string, PositionInfo>>` |
+| `getPositionsByUserAndTokenAddress` | Get user's positions across all DLMM pools that contain a given token mint         | `Promise<Map<string, PositionInfo>>` |
+| `getLimitOrdersByUserAndTokenAddress` | Get user's limit orders across all DLMM pools that contain a given token mint, grouped by LB pair | `Promise<Map<string, LimitOrderInfo>>` |
 
 ## DLMM instance functions
 

package/dist/index.d.ts

@@ -12303,6 +12303,13 @@ interface PositionInfo {
     tokenY: TokenReserve;
     lbPairPositionsData: Array<LbPosition>;
 }
+interface LimitOrderInfo {
+    publicKey: PublicKey;
+    lbPair: LbPair;
+    tokenX: TokenReserve;
+    tokenY: TokenReserve;
+    limitOrders: Array<ParsedLimitOrderWithPubkey>;
+}
 interface FeeInfo {
     baseFeeRatePercentage: Decimal;
     maxFeeRatePercentage: Decimal;
@@ -13564,6 +13571,36 @@ declare class DLMM {
      * Pair account, and the value is an object of PositionInfo
      */
     static getAllLbPairPositionsByUser(connection: Connection, userPubKey: PublicKey, opt?: Opt, getPositionsOpt?: GetPositionsOpt): Promise<Map<string, PositionInfo>>;
+    /**
+     * 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 getPositionsByUserAndTokenAddress(connection: Connection, userPubKey: PublicKey, tokenMint: PublicKey, opt?: Opt, getPositionsOpt?: GetPositionsOpt): Promise<Map<string, PositionInfo>>;
+    /**
+     * 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 getLimitOrdersByUserAndTokenAddress(connection: Connection, userPubKey: PublicKey, tokenMint: PublicKey, opt?: Opt): Promise<Map<string, LimitOrderInfo>>;
     static getPricePerLamport(tokenXDecimal: number, tokenYDecimal: number, price: number): string;
     static getBinIdFromPrice(price: string | number | Decimal, binStep: number, min: boolean): number;
     /**
@@ -26426,4 +26463,4 @@ declare const limitOrderFilter: () => GetProgramAccountsFilter;
 declare const limitOrderOwnerFilter: (owner: PublicKey) => GetProgramAccountsFilter;
 declare const limitOrderLbPairFilter: (lbPair: PublicKey) => GetProgramAccountsFilter;
 
-export { ADMIN, ALT_ADDRESS, AccountName, ActionType, ActivationType, AmountIntoBin, BASIS_POINT_MAX, BIN_ARRAY_BITMAP_FEE, BIN_ARRAY_BITMAP_FEE_BN, BIN_ARRAY_BITMAP_SIZE, BIN_ARRAY_DEFAULT_VERSION, BIN_ARRAY_FEE, BIN_ARRAY_FEE_BN, BidAskParameters, Bin, BinAndAmount, BinArray, BinArrayAccount, BinArrayBitmapExtension, BinArrayBitmapExtensionAccount, BinLiquidity, BinLiquidityDistribution, BinLiquidityReduction, BitmapType, ChunkCallback, ChunkCallbackInfo, ClmmProgram, Clock, ClockLayout, CollectFeeMode, CompressedBinDepositAmount, CompressedBinDepositAmounts, ConcreteFunctionType, CreateRebalancePositionParams, DEFAULT_BIN_PER_POSITION, DLMMError, DlmmSdkError, DynamicOracle, EXTENSION_BINARRAY_BITMAP_SIZE, EmissionRate, ExtendedPositionBinData, FEE_PRECISION, FeeInfo, FeeMode, FunctionType, GetOrCreateATAResponse, GetPositionsOpt, IAccountsCache, IDL, IDynamicOracle, ILM_BASE, IPosition, InitCustomizablePermissionlessPairIx, InitPermissionPairIx, InitializeMultiplePositionAndAddLiquidityByStrategyResponse, InitializeMultiplePositionAndAddLiquidityByStrategyResponse2, LBCLMM_PROGRAM_IDS, LIMIT_ORDER_BIN_DATA_SIZE, LIMIT_ORDER_FEE_SHARE, LIMIT_ORDER_MIN_SIZE, LMRewards, LbClmm, LbPair, LbPairAccount, LbPosition, LimitOrder, LimitOrderBinData, LimitOrderStatus, LiquidityOneSideParameter, LiquidityParameter, LiquidityParameterByStrategy, LiquidityParameterByStrategyOneSide, LiquidityParameterByWeight, LiquidityStrategyParameterBuilder, LiquidityStrategyParameters, MAX_ACTIVE_BIN_SLIPPAGE, MAX_BINS_PER_POSITION, MAX_BIN_ARRAY_SIZE, MAX_BIN_ID_PER_BIN_STEP, MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX, MAX_BIN_PER_LIMIT_ORDER, MAX_CLAIM_ALL_ALLOWED, MAX_EXTRA_BIN_ARRAYS, MAX_FEE_RATE, MAX_RESIZE_LENGTH, MEMO_PROGRAM_ID, Network, Observation, Opt, Oracle, POOL_FEE, POOL_FEE_BN, POSITION_BIN_DATA_SIZE, POSITION_FEE, POSITION_FEE_BN, POSITION_MAX_LENGTH, POSITION_MIN_SIZE, PRECISION, PairLockInfo, PairStatus, PairType, ParsedLimitOrderWithPubkey, PlaceLimitOrderParams, PositionBinData, PositionData, PositionInfo, PositionLockInfo, PositionPermission, PositionV2, PositionV2Wrapper, PositionVersion, PresetParameter, PresetParameter2, ProgramStrategyParameter, ProgramStrategyType, REBALANCE_POSITION_PADDING, RebalanceAddLiquidityParam, RebalancePosition, RebalancePositionBinArrayRentalCostQuote, RebalancePositionResponse, RebalanceRemoveLiquidityParam, RebalanceWithDeposit, RebalanceWithWithdraw, RemainingAccountInfo, RemainingAccountsInfoSlice, ResizeSide, ResizeSideEnum, RewardInfo, RewardInfos, Rounding, SCALE, SCALE_OFFSET, SIMULATION_USER, SeedLiquidityCostBreakdown, SeedLiquidityResponse, SeedLiquiditySingleBinResponse, ShrinkMode, SimulateRebalanceResp, Strategy, StrategyParameters, StrategyType, SwapExactOutParams, SwapFee, SwapParams, SwapQuote, SwapQuoteExactOut, SwapWithPriceImpactParams, TInitializeMultiplePositionAndAddLiquidityParamsByStrategy, TInitializePositionAndAddLiquidityParams, TInitializePositionAndAddLiquidityParamsByStrategy, TOKEN_ACCOUNT_FEE, TOKEN_ACCOUNT_FEE_BN, TQuoteCreatePositionParams, TokenReserve, TwapResult, U64_MAX, UserFeeInfo, UserRewardInfo, autoFillXByStrategy, autoFillXByWeight, autoFillYByStrategy, autoFillYByWeight, binArrayLbPairFilter, binDeltaToMinMaxBinId, binIdToBinArrayIndex, buildBitFlagAndNegateStrategyParameters, buildLiquidityStrategyParameters, calculateBidAskDistribution, calculateNormalDistribution, calculatePositionSize, calculateSpotDistribution, calculateTransferFeeExcludedAmount, calculateTransferFeeIncludedAmount, capSlippagePercentage, chunkBinRange, chunkBinRangeIntoExtendedPositions, chunkDepositWithRebalanceEndpoint, chunkPositionBinRange, chunkedFetchMultipleBinArrayBitmapExtensionAccount, chunkedFetchMultiplePoolAccount, chunkedGetMultipleAccountInfos, chunkedGetProgramAccounts, chunks, compressBinAmount, computeBaseFactorFromFeeBps, computeFee, computeFeeFromAmount, computeProtocolFee, createProgram, decodeAccount, decodeExtendedPosition, decodeRewardPerTokenStored, DLMM as default, deriveBinArray, deriveBinArrayBitmapExtension, deriveCustomizablePermissionlessLbPair, deriveEventAuthority, deriveLbPair, deriveLbPair2, deriveLbPairWithPresetParamWithIndexKey, deriveOperator, deriveOracle, derivePermissionLbPair, derivePlaceHolderAccountMeta, derivePosition, derivePresetParameter, derivePresetParameter2, derivePresetParameterWithIndex, deriveReserve, deriveRewardVault, deriveTokenBadge, distributeAmountToCompressedBinsByRatio, encodePositionPermissions, enumerateBins, findNextBinArrayIndexWithLiquidity, findNextBinArrayWithLiquidity, findOptimumDecompressMultiplier, fromWeightDistributionToAmount, fromWeightDistributionToAmountOneSide, generateAmountForBinRange, generateBinAmount, getAccountDiscriminator, getAmountIn, getAmountInBinsAskSide, getAmountInBinsBidSide, getAmountOut, getAndCapMaxActiveBinSlippage, getAutoFillAmountByRebalancedPosition, getBaseFee, getBinArrayAccountMetasCoverage, getBinArrayIndexesCoverage, getBinArrayInfoForNonContiguousBinIds, getBinArrayKeysCoverage, getBinArrayLowerUpperBinId, getBinArraysRequiredByPositionRange, getBinCount, getBinFromBinArray, getBinIdIndexInBinArray, getBinMaxAmountOut, getC, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getExcludedFeeAmount, getExtendedPositionBinCount, getExtraAccountMetasForTransferHook, getFeeMode, getIncludedFeeAmount, getLimitOrderLiquidity, getLiquidityStrategyParameterBuilder, getMultipleMintsExtraAccountMetasForTransferHook, getOrCreateATAInstruction, getPositionCount, getPositionCountByBinCount, getPositionExpandRentExemption, getPositionLowerUpperBinIdWithLiquidity, getPositionRentExemption, getPriceOfBinByBinId, getQPriceBaseFactor, getQPriceFromId, getRebalanceBinArrayIndexesAndBitmapCoverage, getSlippageMaxAmount, getSlippageMinAmount, getTokenBalance, getTokenDecimals, getTokenProgramId, getTokensMintFromPoolAddress, getTotalFee, getVariableFee, isBinIdWithinBinArray, isOverflowDefaultBinArrayBitmap, isPositionNoFee, isPositionNoReward, isSupportLimitOrder, limitOrderFilter, limitOrderLbPairFilter, limitOrderOwnerFilter, mulDiv, mulShr, parseLogs, positionLbPairFilter, positionOwnerFilter, positionV2Filter, presetParameter2BaseFactorFilter, presetParameter2BaseFeePowerFactor, presetParameter2BinStepFilter, range, resetUninvolvedLiquidityParams, sParameters, shlDiv, splitFee, suggestBalancedXParametersFromY, suggestBalancedYParametersFromX, swapExactInQuoteAtBin, swapExactOutQuoteAtBin, toAmountAskSide, toAmountBidSide, toAmountBothSide, toAmountIntoBins, toAmountsBothSideByStrategy, toStrategyParameters, toWeightDistribution, unwrapSOLInstruction, vParameters, wrapOracle, wrapPosition, wrapSOLInstruction };
+export { ADMIN, ALT_ADDRESS, AccountName, ActionType, ActivationType, AmountIntoBin, BASIS_POINT_MAX, BIN_ARRAY_BITMAP_FEE, BIN_ARRAY_BITMAP_FEE_BN, BIN_ARRAY_BITMAP_SIZE, BIN_ARRAY_DEFAULT_VERSION, BIN_ARRAY_FEE, BIN_ARRAY_FEE_BN, BidAskParameters, Bin, BinAndAmount, BinArray, BinArrayAccount, BinArrayBitmapExtension, BinArrayBitmapExtensionAccount, BinLiquidity, BinLiquidityDistribution, BinLiquidityReduction, BitmapType, ChunkCallback, ChunkCallbackInfo, ClmmProgram, Clock, ClockLayout, CollectFeeMode, CompressedBinDepositAmount, CompressedBinDepositAmounts, ConcreteFunctionType, CreateRebalancePositionParams, DEFAULT_BIN_PER_POSITION, DLMMError, DlmmSdkError, DynamicOracle, EXTENSION_BINARRAY_BITMAP_SIZE, EmissionRate, ExtendedPositionBinData, FEE_PRECISION, FeeInfo, FeeMode, FunctionType, GetOrCreateATAResponse, GetPositionsOpt, IAccountsCache, IDL, IDynamicOracle, ILM_BASE, IPosition, InitCustomizablePermissionlessPairIx, InitPermissionPairIx, InitializeMultiplePositionAndAddLiquidityByStrategyResponse, InitializeMultiplePositionAndAddLiquidityByStrategyResponse2, LBCLMM_PROGRAM_IDS, LIMIT_ORDER_BIN_DATA_SIZE, LIMIT_ORDER_FEE_SHARE, LIMIT_ORDER_MIN_SIZE, LMRewards, LbClmm, LbPair, LbPairAccount, LbPosition, LimitOrder, LimitOrderBinData, LimitOrderInfo, LimitOrderStatus, LiquidityOneSideParameter, LiquidityParameter, LiquidityParameterByStrategy, LiquidityParameterByStrategyOneSide, LiquidityParameterByWeight, LiquidityStrategyParameterBuilder, LiquidityStrategyParameters, MAX_ACTIVE_BIN_SLIPPAGE, MAX_BINS_PER_POSITION, MAX_BIN_ARRAY_SIZE, MAX_BIN_ID_PER_BIN_STEP, MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX, MAX_BIN_PER_LIMIT_ORDER, MAX_CLAIM_ALL_ALLOWED, MAX_EXTRA_BIN_ARRAYS, MAX_FEE_RATE, MAX_RESIZE_LENGTH, MEMO_PROGRAM_ID, Network, Observation, Opt, Oracle, POOL_FEE, POOL_FEE_BN, POSITION_BIN_DATA_SIZE, POSITION_FEE, POSITION_FEE_BN, POSITION_MAX_LENGTH, POSITION_MIN_SIZE, PRECISION, PairLockInfo, PairStatus, PairType, ParsedLimitOrderWithPubkey, PlaceLimitOrderParams, PositionBinData, PositionData, PositionInfo, PositionLockInfo, PositionPermission, PositionV2, PositionV2Wrapper, PositionVersion, PresetParameter, PresetParameter2, ProgramStrategyParameter, ProgramStrategyType, REBALANCE_POSITION_PADDING, RebalanceAddLiquidityParam, RebalancePosition, RebalancePositionBinArrayRentalCostQuote, RebalancePositionResponse, RebalanceRemoveLiquidityParam, RebalanceWithDeposit, RebalanceWithWithdraw, RemainingAccountInfo, RemainingAccountsInfoSlice, ResizeSide, ResizeSideEnum, RewardInfo, RewardInfos, Rounding, SCALE, SCALE_OFFSET, SIMULATION_USER, SeedLiquidityCostBreakdown, SeedLiquidityResponse, SeedLiquiditySingleBinResponse, ShrinkMode, SimulateRebalanceResp, Strategy, StrategyParameters, StrategyType, SwapExactOutParams, SwapFee, SwapParams, SwapQuote, SwapQuoteExactOut, SwapWithPriceImpactParams, TInitializeMultiplePositionAndAddLiquidityParamsByStrategy, TInitializePositionAndAddLiquidityParams, TInitializePositionAndAddLiquidityParamsByStrategy, TOKEN_ACCOUNT_FEE, TOKEN_ACCOUNT_FEE_BN, TQuoteCreatePositionParams, TokenReserve, TwapResult, U64_MAX, UserFeeInfo, UserRewardInfo, autoFillXByStrategy, autoFillXByWeight, autoFillYByStrategy, autoFillYByWeight, binArrayLbPairFilter, binDeltaToMinMaxBinId, binIdToBinArrayIndex, buildBitFlagAndNegateStrategyParameters, buildLiquidityStrategyParameters, calculateBidAskDistribution, calculateNormalDistribution, calculatePositionSize, calculateSpotDistribution, calculateTransferFeeExcludedAmount, calculateTransferFeeIncludedAmount, capSlippagePercentage, chunkBinRange, chunkBinRangeIntoExtendedPositions, chunkDepositWithRebalanceEndpoint, chunkPositionBinRange, chunkedFetchMultipleBinArrayBitmapExtensionAccount, chunkedFetchMultiplePoolAccount, chunkedGetMultipleAccountInfos, chunkedGetProgramAccounts, chunks, compressBinAmount, computeBaseFactorFromFeeBps, computeFee, computeFeeFromAmount, computeProtocolFee, createProgram, decodeAccount, decodeExtendedPosition, decodeRewardPerTokenStored, DLMM as default, deriveBinArray, deriveBinArrayBitmapExtension, deriveCustomizablePermissionlessLbPair, deriveEventAuthority, deriveLbPair, deriveLbPair2, deriveLbPairWithPresetParamWithIndexKey, deriveOperator, deriveOracle, derivePermissionLbPair, derivePlaceHolderAccountMeta, derivePosition, derivePresetParameter, derivePresetParameter2, derivePresetParameterWithIndex, deriveReserve, deriveRewardVault, deriveTokenBadge, distributeAmountToCompressedBinsByRatio, encodePositionPermissions, enumerateBins, findNextBinArrayIndexWithLiquidity, findNextBinArrayWithLiquidity, findOptimumDecompressMultiplier, fromWeightDistributionToAmount, fromWeightDistributionToAmountOneSide, generateAmountForBinRange, generateBinAmount, getAccountDiscriminator, getAmountIn, getAmountInBinsAskSide, getAmountInBinsBidSide, getAmountOut, getAndCapMaxActiveBinSlippage, getAutoFillAmountByRebalancedPosition, getBaseFee, getBinArrayAccountMetasCoverage, getBinArrayIndexesCoverage, getBinArrayInfoForNonContiguousBinIds, getBinArrayKeysCoverage, getBinArrayLowerUpperBinId, getBinArraysRequiredByPositionRange, getBinCount, getBinFromBinArray, getBinIdIndexInBinArray, getBinMaxAmountOut, getC, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getExcludedFeeAmount, getExtendedPositionBinCount, getExtraAccountMetasForTransferHook, getFeeMode, getIncludedFeeAmount, getLimitOrderLiquidity, getLiquidityStrategyParameterBuilder, getMultipleMintsExtraAccountMetasForTransferHook, getOrCreateATAInstruction, getPositionCount, getPositionCountByBinCount, getPositionExpandRentExemption, getPositionLowerUpperBinIdWithLiquidity, getPositionRentExemption, getPriceOfBinByBinId, getQPriceBaseFactor, getQPriceFromId, getRebalanceBinArrayIndexesAndBitmapCoverage, getSlippageMaxAmount, getSlippageMinAmount, getTokenBalance, getTokenDecimals, getTokenProgramId, getTokensMintFromPoolAddress, getTotalFee, getVariableFee, isBinIdWithinBinArray, isOverflowDefaultBinArrayBitmap, isPositionNoFee, isPositionNoReward, isSupportLimitOrder, limitOrderFilter, limitOrderLbPairFilter, limitOrderOwnerFilter, mulDiv, mulShr, parseLogs, positionLbPairFilter, positionOwnerFilter, positionV2Filter, presetParameter2BaseFactorFilter, presetParameter2BaseFeePowerFactor, presetParameter2BinStepFilter, range, resetUninvolvedLiquidityParams, sParameters, shlDiv, splitFee, suggestBalancedXParametersFromY, suggestBalancedYParametersFromX, swapExactInQuoteAtBin, swapExactOutQuoteAtBin, toAmountAskSide, toAmountBidSide, toAmountBothSide, toAmountIntoBins, toAmountsBothSideByStrategy, toStrategyParameters, toWeightDistribution, unwrapSOLInstruction, vParameters, wrapOracle, wrapPosition, wrapSOLInstruction };

package/dist/index.js

@@ -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 (0, _web3js.PublicKey)(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 (0, _web3js.PublicKey)(key)
+    );
+    const [clockAccInfo, ...rest] = await chunkedGetMultipleAccountInfos(
+      connection,
+      [_web3js.SYSVAR_CLOCK_PUBKEY, ...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 = _spltoken.AccountLayout.decode(reserveXAccount.data);
+      const reserveAccY = _spltoken.AccountLayout.decode(reserveYAccount.data);
+      const mintX = _spltoken.unpackMint.call(void 0, 
+        reserveAccX.mint,
+        mintXAccount,
+        mintXAccount.owner
+      );
+      const mintY = _spltoken.unpackMint.call(void 0, 
+        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: _nullishCoalesce(mintHookAccountsMap.get(lbPairState.tokenXMint.toBase58()), () => ( []))
+      };
+      const tokenY = {
+        publicKey: lbPairState.tokenYMint,
+        reserve: lbPairState.reserveY,
+        amount: reserveAccY.amount,
+        mint: mintY,
+        owner: tokenYProgram,
+        transferHookAccountMetas: _nullishCoalesce(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 (0, _decimaljs2.default)(price).mul(new (0, _decimaljs2.default)(10 ** (tokenYDecimal - tokenXDecimal))).toString();
   }