@meteora-ag/dlmm 1.9.8 → 1.9.10-rc.0

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

@@ -12302,6 +12302,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;
@@ -13563,6 +13570,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;
     /**
@@ -14332,7 +14369,8 @@ declare class DLMM {
      *    - `limitOrderPubkey`: The public key of the limit-order account to cancel.
      *    - `owner`: The owner of the limit-order account and transaction fee payer.
      *    - `binIds`: Bin IDs to cancel from the limit order.
-     * @returns {Promise<Transaction>} A transaction that cancels the limit order and handles SOL unwrap when needed.
+     * @returns {Promise<Transaction>} A transaction that cancels the limit order, ensures owner ATAs for both pool
+     *    mints (including idempotent creates for non-SOL legs), and unwraps SOL when applicable.
      */
     cancelLimitOrder({ limitOrderPubkey, owner, rentReceiver, binIds, }: {
         limitOrderPubkey: PublicKey;
@@ -26424,4 +26462,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_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_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

@@ -10266,6 +10266,7 @@ var DlmmSdkError = class extends Error {
 
 
 
+
 // src/dlmm/types/index.ts
 
 
@@ -15354,7 +15355,8 @@ async function chunkDepositWithRebalanceEndpoint(dlmm, strategy, slippagePercent
       const initBitmapIx = await dlmm.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
         binArrayBitmapExtension: bitmapPubkey,
         lbPair: dlmm.pubkey,
-        funder: payer
+        funder: payer,
+        rent: _web3js.SYSVAR_RENT_PUBKEY
       }).instruction();
       initBitmapIxs.push(initBitmapIx);
       binArrayOrBitmapInitTracking.add(bitmapPubkey.toBase58());
@@ -16733,6 +16735,209 @@ 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 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: []
+        // Not required for read-only limit order processing
+      };
+      const tokenY = {
+        publicKey: lbPairState.tokenYMint,
+        reserve: lbPairState.reserveY,
+        amount: reserveAccY.amount,
+        mint: mintY,
+        owner: tokenYProgram,
+        transferHookAccountMetas: []
+        // Not required for read-only limit order processing
+      };
+      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();
   }
@@ -20731,7 +20936,8 @@ var DLMM = class {
                 await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
                   binArrayBitmapExtension,
                   funder: payer,
-                  lbPair: this.pubkey
+                  lbPair: this.pubkey,
+                  rent: _web3js.SYSVAR_RENT_PUBKEY
                 }).instruction()
               );
               appendedInitBinArrayBitmap = true;
@@ -20930,7 +21136,8 @@ var DLMM = class {
           await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
             binArrayBitmapExtension,
             funder: payer,
-            lbPair: this.pubkey
+            lbPair: this.pubkey,
+            rent: _web3js.SYSVAR_RENT_PUBKEY
           }).instruction()
         );
         binArrayBitmapLamports = binArrayBitmapLamports.add(
@@ -21346,7 +21553,8 @@ var DLMM = class {
         const initializeBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
           binArrayBitmapExtension: binArrayBitMapExtensionPubkey,
           funder: owner,
-          lbPair: this.pubkey
+          lbPair: this.pubkey,
+          rent: _web3js.SYSVAR_RENT_PUBKEY
         }).instruction();
         preInstructions.push(initializeBitmapExtensionIx);
       }
@@ -21754,7 +21962,8 @@ var DLMM = class {
         const initBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
           binArrayBitmapExtension: binArrayBitmap,
           funder: owner,
-          lbPair: this.pubkey
+          lbPair: this.pubkey,
+          rent: _web3js.SYSVAR_RENT_PUBKEY
         }).preInstructions([
           _web3js.ComputeBudgetProgram.setComputeUnitLimit({
             units: DEFAULT_INIT_BIN_ARRAY_CU
@@ -21970,7 +22179,8 @@ var DLMM = class {
       const initializeBitmapExtensionIx = await this.program.methods.initializeBinArrayBitmapExtension().accountsPartial({
         binArrayBitmapExtension,
         funder: owner,
-        lbPair: this.pubkey
+        lbPair: this.pubkey,
+        rent: _web3js.SYSVAR_RENT_PUBKEY
       }).instruction();
       preInstructions.push(initializeBitmapExtensionIx);
     }
@@ -22062,7 +22272,8 @@ var DLMM = class {
    *    - `limitOrderPubkey`: The public key of the limit-order account to cancel.
    *    - `owner`: The owner of the limit-order account and transaction fee payer.
    *    - `binIds`: Bin IDs to cancel from the limit order.
-   * @returns {Promise<Transaction>} A transaction that cancels the limit order and handles SOL unwrap when needed.
+   * @returns {Promise<Transaction>} A transaction that cancels the limit order, ensures owner ATAs for both pool
+   *    mints (including idempotent creates for non-SOL legs), and unwraps SOL when applicable.
    */
   async cancelLimitOrder({
     limitOrderPubkey,
@@ -22090,7 +22301,20 @@ var DLMM = class {
       true,
       this.tokenY.owner
     );
-    if (this.tokenX.mint.address.equals(_spltoken.NATIVE_MINT) && !_optionalChain([this, 'access', _177 => _177.opt, 'optionalAccess', _178 => _178.skipSolWrappingOperation])) {
+    if (this.tokenX.mint.address.equals(_spltoken.NATIVE_MINT)) {
+      if (!_optionalChain([this, 'access', _177 => _177.opt, 'optionalAccess', _178 => _178.skipSolWrappingOperation])) {
+        preInstructions.push(
+          _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+            owner,
+            userTokenX,
+            owner,
+            this.tokenX.mint.address,
+            this.tokenX.owner
+          )
+        );
+        postInstructions.push(unwrapSOLInstruction(owner));
+      }
+    } else {
       preInstructions.push(
         _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
           owner,
@@ -22100,9 +22324,21 @@ var DLMM = class {
           this.tokenX.owner
         )
       );
-      postInstructions.push(unwrapSOLInstruction(owner));
     }
-    if (this.tokenY.mint.address.equals(_spltoken.NATIVE_MINT) && !_optionalChain([this, 'access', _179 => _179.opt, 'optionalAccess', _180 => _180.skipSolWrappingOperation])) {
+    if (this.tokenY.mint.address.equals(_spltoken.NATIVE_MINT)) {
+      if (!_optionalChain([this, 'access', _179 => _179.opt, 'optionalAccess', _180 => _180.skipSolWrappingOperation])) {
+        preInstructions.push(
+          _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+            owner,
+            userTokenY,
+            owner,
+            this.tokenY.mint.address,
+            this.tokenY.owner
+          )
+        );
+        postInstructions.push(unwrapSOLInstruction(owner));
+      }
+    } else {
       preInstructions.push(
         _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
           owner,
@@ -22112,7 +22348,6 @@ var DLMM = class {
           this.tokenY.owner
         )
       );
-      postInstructions.push(unwrapSOLInstruction(owner));
     }
     const closeLimitOrderIx = await this.program.methods.closeLimitOrderIfEmpty().accountsPartial({
       limitOrder: limitOrderPubkey,