@meteora-ag/dlmm 1.6.0-rc.18 → 1.6.0-rc.2

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import * as _coral_xyz_anchor from '@coral-xyz/anchor';
 import { Program, BN as BN$1, IdlAccounts, ProgramAccount, IdlTypes, EventParser } from '@coral-xyz/anchor';
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, Connection, AccountMeta, Keypair, TransactionInstruction, Cluster, Transaction } from '@solana/web3.js';
+import { PublicKey, Connection, AccountMeta, Keypair, TransactionInstruction, Cluster, AccountInfo, Transaction } from '@solana/web3.js';
 import Decimal from 'decimal.js';
+import { IdlDiscriminator } from '@coral-xyz/anchor/dist/cjs/idl';
 import { Mint } from '@solana/spl-token';
 import { AllAccountsMap } from '@coral-xyz/anchor/dist/cjs/program/namespace/types';
 import BN from 'bn.js';
-import { IdlDiscriminator } from '@coral-xyz/anchor/dist/cjs/idl';
 
 /**
  * Program IDL in camelCase format in order to be used in JS/TS.
@@ -9126,6 +9126,21 @@ type LbClmm = {
     ];
 };
 
+declare function buildBitFlagAndNegateStrategyParameters(x0: BN, y0: BN, deltaX: BN, deltaY: BN): {
+    bitFlag: number;
+    x0: BN;
+    y0: BN;
+    deltaX: BN;
+    deltaY: BN;
+};
+interface AmountIntoBin {
+    binId: BN;
+    amountX: BN;
+    amountY: BN;
+}
+declare function getAmountInBinsBidSide(activeId: BN, minDeltaId: BN, maxDeltaId: BN, deltaY: BN, y0: BN): AmountIntoBin[];
+declare function getAmountInBinsAskSide(activeId: BN, binStep: BN, minDeltaId: BN, maxDeltaId: BN, deltaX: BN, x0: BN): AmountIntoBin[];
+declare function toAmountIntoBins(activeId: BN, minDeltaId: BN, maxDeltaId: BN, deltaX: BN, deltaY: BN, x0: BN, y0: BN, binStep: BN, favorXInActiveBin: boolean): AmountIntoBin[];
 interface SimulateWithdrawResult {
     liquidityAndFeeXWithdrawn: BN;
     liquidityAndFeeYWithdrawn: BN;
@@ -9210,6 +9225,43 @@ interface SimulateRebalanceResp {
     withdrawParams: RebalanceRemoveLiquidityParam[];
     rentalCostLamports: BN;
 }
+declare function getRebalanceBinArrayIndexesAndBitmapCoverage(adds: RebalanceAddLiquidityParam[], removes: RebalanceRemoveLiquidityParam[], activeId: number, pairAddress: PublicKey, programId: PublicKey): {
+    binArrayIndexes: BN[];
+    binArrayBitmap: PublicKey;
+};
+
+interface LiquidityStrategyParameters {
+    x0: BN;
+    y0: BN;
+    deltaX: BN;
+    deltaY: BN;
+}
+interface BidAskParameters {
+    base: BN;
+    delta: BN;
+}
+interface LiquidityStrategyParameterBuilder {
+    findXParameters(amountX: BN, minDeltaId: BN, maxDeltaId: BN, binStep: BN, activeId: BN): BidAskParameters;
+    findYParameters(amountY: BN, minDeltaId: BN, maxDeltaId: BN, activeId: BN): BidAskParameters;
+    suggestBalancedXParametersFromY(activeId: BN, binStep: BN, favorXInActiveBin: boolean, minDeltaId: BN, maxDeltaId: BN, amountY: BN): BidAskParameters & {
+        amountX: BN;
+    };
+    suggestBalancedYParametersFromX(activeId: BN, binStep: BN, favorXInActiveBin: boolean, minDeltaId: BN, maxDeltaId: BN, amountXInQuoteValue: BN): BidAskParameters & {
+        amountY: BN;
+    };
+}
+declare function getLiquidityStrategyParameterBuilder(strategyType: StrategyType): LiquidityStrategyParameterBuilder;
+declare function suggestBalancedXParametersFromY(y0: BN, deltaY: BN, minDeltaId: BN, maxDeltaId: BN, activeId: BN, binStep: BN, favorXInActiveBin: boolean, builder: LiquidityStrategyParameterBuilder): BidAskParameters & {
+    amountX: BN;
+};
+declare function getAutoFillAmountByRebalancedPosition(rebalancePosition: RebalancePosition, strategyType: StrategyType): {
+    amount: BN;
+    isBidSide: boolean;
+};
+declare function suggestBalancedYParametersFromX(x0: BN, deltaX: BN, minDeltaId: BN, maxDeltaId: BN, activeId: BN, binStep: BN, favorXInActiveBin: boolean, builder: LiquidityStrategyParameterBuilder): BidAskParameters & {
+    amountY: BN;
+};
+declare function buildLiquidityStrategyParameters(amountX: BN, amountY: BN, minDeltaId: BN, maxDeltaId: BN, binStep: BN, favorXInActiveId: boolean, activeId: BN, strategyParameterBuilder: LiquidityStrategyParameterBuilder): LiquidityStrategyParameters;
 
 interface BinAndAmount {
     binId: number;
@@ -9360,6 +9412,14 @@ interface TInitializePositionAndAddLiquidityParamsByStrategy {
     user: PublicKey;
     slippage?: number;
 }
+interface InitializeMultiplePositionAndAddLiquidityByStrategyResponse {
+    instructionsByPositions: {
+        positionKeypair: Keypair;
+        initializePositionIx: TransactionInstruction;
+        initializeAtaIxs: TransactionInstruction[];
+        addLiquidityIxs: TransactionInstruction[][];
+    }[];
+}
 interface TInitializeMultiplePositionAndAddLiquidityParamsByStrategy {
     totalXAmount: BN$1;
     totalYAmount: BN$1;
@@ -9592,31 +9652,6 @@ interface RebalancePositionBinArrayRentalCostQuote {
     bitmapExtensionCost: number;
 }
 
-/** private */
-declare function derivePresetParameterWithIndex(index: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveLbPairWithPresetParamWithIndexKey(presetParameterKey: PublicKey, tokenX: PublicKey, tokenY: PublicKey, programId: PublicKey): [PublicKey, number];
-/**
- *
- * @deprecated Use derivePresetParameter2
- */
-declare function derivePresetParameter(binStep: BN$1, programId: PublicKey): [PublicKey, number];
-declare function derivePresetParameter2(binStep: BN$1, baseFactor: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveLbPair2(tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, baseFactor: BN$1, programId: PublicKey): [PublicKey, number];
-/**
- *
- * @deprecated Use deriveLbPair2
- */
-declare function deriveLbPair(tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveCustomizablePermissionlessLbPair(tokenX: PublicKey, tokenY: PublicKey, programId: PublicKey): [PublicKey, number];
-declare function derivePermissionLbPair(baseKey: PublicKey, tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveOracle(lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
-declare function derivePosition(lbPair: PublicKey, base: PublicKey, lowerBinId: BN$1, width: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveBinArray(lbPair: PublicKey, index: BN$1, programId: PublicKey): [PublicKey, number];
-declare function deriveReserve(token: PublicKey, lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
-declare function deriveTokenBadge(mint: PublicKey, programId: PublicKey): [PublicKey, number];
-declare function deriveEventAuthority(programId: PublicKey): [PublicKey, number];
-declare function deriveRewardVault(lbPair: PublicKey, rewardIndex: BN$1, programId: PublicKey): [PublicKey, number];
-
 /** private */
 declare function isOverflowDefaultBinArrayBitmap(binArrayIndex: BN$1): boolean;
 declare function deriveBinArrayBitmapExtension(lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
@@ -9658,6 +9693,238 @@ declare function updateBinArray(activeId: BN$1, clock: Clock, allRewardInfos: Re
     }[];
 };
 
+/** private */
+declare function derivePresetParameterWithIndex(index: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveLbPairWithPresetParamWithIndexKey(presetParameterKey: PublicKey, tokenX: PublicKey, tokenY: PublicKey, programId: PublicKey): [PublicKey, number];
+/**
+ *
+ * @deprecated Use derivePresetParameter2
+ */
+declare function derivePresetParameter(binStep: BN$1, programId: PublicKey): [PublicKey, number];
+declare function derivePresetParameter2(binStep: BN$1, baseFactor: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveLbPair2(tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, baseFactor: BN$1, programId: PublicKey): [PublicKey, number];
+/**
+ *
+ * @deprecated Use deriveLbPair2
+ */
+declare function deriveLbPair(tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveCustomizablePermissionlessLbPair(tokenX: PublicKey, tokenY: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function derivePermissionLbPair(baseKey: PublicKey, tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveOracle(lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function derivePosition(lbPair: PublicKey, base: PublicKey, lowerBinId: BN$1, width: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveBinArray(lbPair: PublicKey, index: BN$1, programId: PublicKey): [PublicKey, number];
+declare function deriveReserve(token: PublicKey, lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function deriveTokenBadge(mint: PublicKey, programId: PublicKey): [PublicKey, number];
+declare function deriveEventAuthority(programId: PublicKey): [PublicKey, number];
+declare function deriveRewardVault(lbPair: PublicKey, rewardIndex: BN$1, programId: PublicKey): [PublicKey, number];
+declare function derivePlaceHolderAccountMeta(programId: PublicKey): AccountMeta;
+
+declare function getBaseFee(binStep: number, sParameter: sParameters): BN$1;
+declare function getVariableFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN$1;
+declare function getTotalFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN$1;
+declare function computeFee(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmount: BN$1): BN$1;
+declare function computeFeeFromAmount(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmountWithFees: BN$1): BN$1;
+declare function computeProtocolFee(feeAmount: BN$1, sParameter: sParameters): BN$1;
+declare function swapExactOutQuoteAtBin(bin: Bin, binStep: number, sParameter: sParameters, vParameter: vParameters, outAmount: BN$1, swapForY: boolean): {
+    amountIn: BN$1;
+    amountOut: BN$1;
+    fee: BN$1;
+    protocolFee: BN$1;
+};
+declare function swapExactInQuoteAtBin(bin: Bin, binStep: number, sParameter: sParameters, vParameter: vParameters, inAmount: BN$1, swapForY: boolean): {
+    amountIn: BN$1;
+    amountOut: BN$1;
+    fee: BN$1;
+    protocolFee: BN$1;
+};
+
+/**
+ * It fetches the pool account from the AMM program, and returns the mint addresses for the two tokens
+ * @param {Connection} connection - Connection - The connection to the Solana cluster
+ * @param {string} poolAddress - The address of the pool account.
+ * @returns The tokenAMint and tokenBMint addresses for the pool.
+ */
+declare function getTokensMintFromPoolAddress(connection: Connection, poolAddress: string, opt?: {
+    cluster?: Cluster;
+    programId?: PublicKey;
+}): Promise<{
+    tokenXMint: PublicKey;
+    tokenYMint: PublicKey;
+}>;
+declare function getTokenProgramId(lbPairState: LbPair): {
+    tokenXProgram: PublicKey;
+    tokenYProgram: PublicKey;
+};
+
+interface IPosition {
+    address(): PublicKey;
+    lowerBinId(): BN;
+    upperBinId(): BN;
+    liquidityShares(): BN[];
+    rewardInfos(): UserRewardInfo[];
+    feeInfos(): UserFeeInfo[];
+    lastUpdatedAt(): BN;
+    lbPair(): PublicKey;
+    totalClaimedFeeXAmount(): BN;
+    totalClaimedFeeYAmount(): BN;
+    totalClaimedRewards(): BN[];
+    operator(): PublicKey;
+    lockReleasePoint(): BN;
+    feeOwner(): PublicKey;
+    owner(): PublicKey;
+    getBinArrayIndexesCoverage(): BN[];
+    getBinArrayKeysCoverage(programId: PublicKey): PublicKey[];
+    version(): PositionVersion;
+    width(): BN;
+}
+interface CombinedPositionBinData {
+    liquidityShares: BN[];
+    rewardInfos: UserRewardInfo[];
+    feeInfos: UserFeeInfo[];
+}
+declare function wrapPosition(program: Program<LbClmm>, key: PublicKey, account: AccountInfo<Buffer>): IPosition;
+declare class PositionV2Wrapper implements IPosition {
+    positionAddress: PublicKey;
+    inner: PositionV2;
+    extended: ExtendedPositionBinData[];
+    combinedPositionBinData: CombinedPositionBinData;
+    constructor(positionAddress: PublicKey, inner: PositionV2, extended: ExtendedPositionBinData[], combinedPositionBinData: CombinedPositionBinData);
+    address(): PublicKey;
+    totalClaimedRewards(): BN[];
+    feeOwner(): PublicKey;
+    lockReleasePoint(): BN;
+    operator(): PublicKey;
+    totalClaimedFeeYAmount(): BN;
+    totalClaimedFeeXAmount(): BN;
+    lbPair(): PublicKey;
+    lowerBinId(): BN;
+    upperBinId(): BN;
+    liquidityShares(): BN[];
+    rewardInfos(): UserRewardInfo[];
+    feeInfos(): UserFeeInfo[];
+    lastUpdatedAt(): BN;
+    getBinArrayIndexesCoverage(): BN[];
+    getBinArrayKeysCoverage(programId: PublicKey): PublicKey[];
+    version(): PositionVersion;
+    owner(): PublicKey;
+    width(): BN;
+}
+
+declare function getBinArrayIndexesCoverage(lowerBinId: BN, upperBinId: BN): BN[];
+declare function getBinArrayKeysCoverage(lowerBinId: BN, upperBinId: BN, lbPair: PublicKey, programId: PublicKey): PublicKey[];
+declare function getBinArrayAccountMetasCoverage(lowerBinId: BN, upperBinId: BN, lbPair: PublicKey, programId: PublicKey): AccountMeta[];
+declare function getPositionLowerUpperBinIdWithLiquidity(position: PositionData): {
+    lowerBinId: BN;
+    upperBinId: BN;
+} | null;
+declare function isPositionNoFee(position: PositionData): boolean;
+declare function isPositionNoReward(position: PositionData): boolean;
+/**
+ * Divides a range of bin IDs into chunks, each with a maximum length defined by POSITION_MAX_LENGTH,
+ * and returns an array of objects representing the lower and upper bin IDs for each chunk.
+ *
+ * @param {number} minBinId - The starting bin ID of the range.
+ * @param {number} maxBinId - The ending bin ID of the range.
+ * @returns {{ lowerBinId: number; upperBinId: number }[]} An array of objects, each containing a
+ *   'lowerBinId' and 'upperBinId', representing the range of bin IDs in each chunk.
+ */
+declare function chunkBinRangeIntoExtendedPositions(minBinId: number, maxBinId: number): {
+    lowerBinId: number;
+    upperBinId: number;
+}[];
+/**
+ * Divides a range of bin IDs into chunks, each with a length defined by DEFAULT_BIN_PER_POSITION,
+ * and returns an array of objects representing the lower and upper bin IDs for each chunk.
+ * Mainly used for chunking bin range to execute multiple add/remove liquidity, claim fee/reward
+ *
+ * @param {number} minBinId - The starting bin ID of the range.
+ * @param {number} maxBinId - The ending bin ID of the range.
+ * @returns {{ lowerBinId: number; upperBinId: number }[]} An array of objects, each containing a
+ *   'lowerBinId' and 'upperBinId', representing the range of bin IDs in each chunk.
+ */
+declare function chunkBinRange(minBinId: number, maxBinId: number): {
+    lowerBinId: number;
+    upperBinId: number;
+}[];
+declare function chunkPositionBinRange(position: LbPosition, minBinId: number, maxBinId: number): {
+    minBinId: number;
+    maxBinId: number;
+    amountX: BN;
+    amountY: BN;
+    feeXAmount: BN;
+    feeYAmount: BN;
+    rewardAmounts: BN[];
+}[];
+declare function calculatePositionSize(binCount: BN): BN;
+/**
+ * Get the minimum balance required to pay for the rent exemption of a
+ * position with the given bin count.
+ *
+ * @param connection The connection to the Solana RPC node.
+ * @param binCount The number of bins in the position.
+ * @returns The minimum balance required to pay for the rent exemption.
+ */
+declare function getPositionRentExemption(connection: Connection, binCount: BN): Promise<number>;
+/**
+ * Calculate the minimum lamports required to expand a position to a given
+ * width.
+ *
+ * The function takes into account the current width of the position and the
+ * width to expand to. If the expanded width is less than or equal to the
+ * default bin count per position, the function returns 0.
+ *
+ * @param currentMinBinId The current minimum bin ID of the position.
+ * @param currentMaxBinId The current maximum bin ID of the position.
+ * @param connection The connection to the Solana RPC node.
+ * @param binCountToExpand The number of bins to expand the position by.
+ * @returns The minimum lamports required to expand the position to the given
+ * width.
+ */
+declare function getPositionExpandRentExemption(currentMinBinId: BN, currentMaxBinId: BN, connection: Connection, binCountToExpand: BN): Promise<number>;
+/**
+ * Calculate the number of extended bins in a position.
+ *
+ * @param minBinId The minimum bin ID of the position.
+ * @param maxBinId The maximum bin ID of the position.
+ * @returns The number of extended bins in the position. If the position width is
+ * less than or equal to the default bin count per position, returns 0.
+ */
+declare function getExtendedPositionBinCount(minBinId: BN, maxBinId: BN): BN;
+/**
+ * Decode the extended position data.
+ *
+ * @param base The base position with the base data.
+ * @param program The program that the position is associated with.
+ * @param bytes The buffer of bytes to decode.
+ * @returns The decoded extended position data.
+ */
+declare function decodeExtendedPosition(base: PositionV2, program: Program<LbClmm>, bytes: Buffer): ExtendedPositionBinData[];
+
+/**
+ * Given a strategy type and amounts of X and Y, returns the distribution of liquidity.
+ * @param activeId The bin id of the active bin.
+ * @param binStep The step size of each bin.
+ * @param minBinId The min bin id.
+ * @param maxBinId The max bin id.
+ * @param amountX The amount of X token to deposit.
+ * @param amountY The amount of Y token to deposit.
+ * @param amountXInActiveBin The amount of X token in the active bin.
+ * @param amountYInActiveBin The amount of Y token in the active bin.
+ * @param strategyType The strategy type.
+ * @param mintX The mint info of X token. Get from DLMM instance.
+ * @param mintY The mint info of Y token. Get from DLMM instance.
+ * @param clock The clock info. Get from DLMM instance.
+ * @returns The distribution of liquidity.
+ */
+declare function toAmountsBothSideByStrategy(activeId: number, binStep: number, minBinId: number, maxBinId: number, amountX: BN$1, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, strategyType: StrategyType, mintX: Mint, mintY: Mint, clock: Clock): {
+    binId: number;
+    amountX: BN$1;
+    amountY: BN$1;
+}[];
+declare function autoFillYByStrategy(activeId: number, binStep: number, amountX: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, minBinId: number, maxBinId: number, strategyType: StrategyType): BN$1;
+declare function autoFillXByStrategy(activeId: number, binStep: number, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, minBinId: number, maxBinId: number, strategyType: StrategyType): BN$1;
+declare function toStrategyParameters({ maxBinId, minBinId, strategyType, singleSidedX, }: StrategyParameters): ProgramStrategyParameter;
+
 declare function getPriceOfBinByBinId(binId: number, binStep: number): Decimal;
 /** private */
 declare function toWeightDistribution(amountX: BN$1, amountY: BN$1, distributions: {
@@ -9726,25 +9993,6 @@ declare function fromWeightDistributionToAmount(amountX: BN$1, amountY: BN$1, di
     amountY: BN$1;
 }[];
 
-declare function getBaseFee(binStep: number, sParameter: sParameters): BN$1;
-declare function getVariableFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN$1;
-declare function getTotalFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN$1;
-declare function computeFee(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmount: BN$1): BN$1;
-declare function computeFeeFromAmount(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmountWithFees: BN$1): BN$1;
-declare function computeProtocolFee(feeAmount: BN$1, sParameter: sParameters): BN$1;
-declare function swapExactOutQuoteAtBin(bin: Bin, binStep: number, sParameter: sParameters, vParameter: vParameters, outAmount: BN$1, swapForY: boolean): {
-    amountIn: BN$1;
-    amountOut: BN$1;
-    fee: BN$1;
-    protocolFee: BN$1;
-};
-declare function swapExactInQuoteAtBin(bin: Bin, binStep: number, sParameter: sParameters, vParameter: vParameters, inAmount: BN$1, swapForY: boolean): {
-    amountIn: BN$1;
-    amountOut: BN$1;
-    fee: BN$1;
-    protocolFee: BN$1;
-};
-
 /**
  * Distribute totalAmount to all bid side bins according to given distributions.
  * @param activeId active bin id
@@ -9810,49 +10058,6 @@ declare function autoFillXByWeight(activeId: number, binStep: number, amountY: B
     weight: number;
 }[]): BN$1;
 
-/**
- * Given a strategy type and amounts of X and Y, returns the distribution of liquidity.
- * @param activeId The bin id of the active bin.
- * @param binStep The step size of each bin.
- * @param minBinId The min bin id.
- * @param maxBinId The max bin id.
- * @param amountX The amount of X token to deposit.
- * @param amountY The amount of Y token to deposit.
- * @param amountXInActiveBin The amount of X token in the active bin.
- * @param amountYInActiveBin The amount of Y token in the active bin.
- * @param strategyType The strategy type.
- * @param mintX The mint info of X token. Get from DLMM instance.
- * @param mintY The mint info of Y token. Get from DLMM instance.
- * @param clock The clock info. Get from DLMM instance.
- * @returns The distribution of liquidity.
- */
-declare function toAmountsBothSideByStrategy(activeId: number, binStep: number, minBinId: number, maxBinId: number, amountX: BN$1, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, strategyType: StrategyType, mintX: Mint, mintY: Mint, clock: Clock): {
-    binId: number;
-    amountX: BN$1;
-    amountY: BN$1;
-}[];
-declare function autoFillYByStrategy(activeId: number, binStep: number, amountX: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, minBinId: number, maxBinId: number, strategyType: StrategyType): BN$1;
-declare function autoFillXByStrategy(activeId: number, binStep: number, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, minBinId: number, maxBinId: number, strategyType: StrategyType): BN$1;
-declare function toStrategyParameters({ maxBinId, minBinId, strategyType, singleSidedX, }: StrategyParameters): ProgramStrategyParameter;
-
-/**
- * It fetches the pool account from the AMM program, and returns the mint addresses for the two tokens
- * @param {Connection} connection - Connection - The connection to the Solana cluster
- * @param {string} poolAddress - The address of the pool account.
- * @returns The tokenAMint and tokenBMint addresses for the pool.
- */
-declare function getTokensMintFromPoolAddress(connection: Connection, poolAddress: string, opt?: {
-    cluster?: Cluster;
-    programId?: PublicKey;
-}): Promise<{
-    tokenXMint: PublicKey;
-    tokenYMint: PublicKey;
-}>;
-declare function getTokenProgramId(lbPairState: LbPair): {
-    tokenXProgram: PublicKey;
-    tokenYProgram: PublicKey;
-};
-
 declare function chunks<T>(array: T[], size: number): T[][];
 declare function range<T>(min: number, max: number, mapfn: (i: number) => T): T[];
 declare function chunkedFetchMultiplePoolAccount(program: ClmmProgram, pks: PublicKey[], chunkSize?: number): Promise<{
@@ -9960,7 +10165,78 @@ type Opt = {
 declare function createProgram(connection: Connection, opt?: Opt): Program<LbClmm>;
 declare function decodeAccount<T extends LbPair | BinArrayBitmapExtension | BinArray | PositionV2 | Position | PresetParameter | PresetParameter2>(program: Program<LbClmm>, accountName: AccountName, buffer: Buffer): T;
 declare function getAccountDiscriminator(accountName: AccountName): IdlDiscriminator;
+/**
+ * Caps a slippage percentage to be between 0 and 100.
+ * @param slippage The slippage percentage to be capped.
+ * @returns The capped slippage percentage.
+ */
 declare function capSlippagePercentage(slippage: number): number;
+/**
+ * Given a slippage percentage and a bin step, calculate the maximum number of bins
+ * that the user is willing to allow the active bin to drift from the target price.
+ * If the slippage percentage is 0 or null, return the maxActiveBinSlippage instead.
+ *
+ * @param slippagePercentage The slippage percentage in basis points.
+ * @param binStep The bin step of the pair.
+ * @param maxActiveBinSlippage The maximum number of bins that the active bin can drift.
+ * @returns The maximum number of bins that the user is willing to allow the active bin to drift.
+ */
+declare function getAndCapMaxActiveBinSlippage(slippagePercentage: number, binStep: number, maxActiveBinSlippage: number): number;
+/**
+ * Calculates the number of bins in a given range.
+ *
+ * @param minBinId The minimum bin id of the range.
+ * @param maxBinId The maximum bin id of the range.
+ * @returns The number of bins in the range.
+ */
+declare function getBinCount(minBinId: number, maxBinId: number): number;
+/**
+ * Calculates the maximum amount of tokens after applying slippage to the given amount.
+ *
+ * @param amount The amount of tokens before slippage.
+ * @param slippage The percentage of slippage to apply.
+ * @returns The maximum amount of tokens after applying slippage. If the slippage is 100%, the maximum amount is U64_MAX.
+ *
+ **/
+declare function getSlippageMaxAmount(amount: BN$1, slippage: number): BN$1;
+/**
+ * Calculates the minimum amount of tokens after applying slippage to the given amount.
+ *
+ * @param amount The amount of tokens before slippage.
+ * @param slippage The percentage of slippage to apply.
+ * @returns The minimum amount of tokens after applying slippage.
+ */
+declare function getSlippageMinAmount(amount: BN$1, slippage: number): BN$1;
+/**
+ * Calculates the number of positions required to cover a range of bins.
+ *
+ * @param binCount The number of bins in the range.
+ * @returns The number of positions required to cover the range of bins.
+ */
+declare function getPositionCountByBinCount(binCount: number): number;
+/**
+ * Adjusts the liquidity parameters to reset uninvolved liquidity based on delta IDs.
+ *
+ * This function modifies the provided liquidity strategy parameters by resetting
+ * the x0, y0, deltaX, and deltaY values when certain conditions regarding the
+ * minDeltaId and maxDeltaId are met. If the maxDeltaId is less than or equal
+ * to the end of the bid side delta ID, x0 and deltaX are set to zero. If the
+ * minDeltaId is greater than or equal to the start of the ask side delta ID,
+ * y0 and deltaY are set to zero.
+ *
+ * @param minDeltaId - The minimum delta ID.
+ * @param maxDeltaId - The maximum delta ID.
+ * @param favorXInActiveId - A boolean indicating if X is favored in the active bin.
+ * @param params - The liquidity strategy parameters containing x0, y0, deltaX, and deltaY.
+ * @returns An object containing the adjusted x0, y0, deltaX, and deltaY values.
+ */
+declare function resetUninvolvedLiquidityParams(minDeltaId: BN$1, maxDeltaId: BN$1, favorXInActiveId: boolean, params: LiquidityStrategyParameters): {
+    x0: BN$1;
+    y0: BN$1;
+    deltaX: BN$1;
+    deltaY: BN$1;
+};
+declare function chunkDepositWithRebalanceEndpoint(dlmm: DLMM, strategy: StrategyParameters, slippagePercentage: number, maxActiveBinSlippage: number, position: PublicKey, positionMinBinId: number, positionMaxBinId: number, liquidityStrategyParameters: LiquidityStrategyParameters, owner: PublicKey, payer: PublicKey, simulateCU: boolean): Promise<TransactionInstruction[][]>;
 
 declare class DLMM {
     pubkey: PublicKey;
@@ -10306,6 +10582,10 @@ declare class DLMM {
         binArrayCost: Decimal;
     }>;
     quoteCreatePosition({ strategy }: TQuoteCreatePositionParams): Promise<{
+        positionCount: number;
+        positionCost: number;
+        positionReallocCost: number;
+        bitmapExtensionCost: number;
         binArraysCount: number;
         binArrayCost: number;
         transactionCount: number;
@@ -10334,6 +10614,33 @@ declare class DLMM {
      * - `version`: The version of the position (in this case, `Position.V2`)
      */
     getPosition(positionPubKey: PublicKey): Promise<LbPosition>;
+    /**
+     * Creates multiple positions and adds liquidity by strategy without chainsaw issues.
+     * @param positionKeypairGenerator A function that generates a specified number of keypairs.
+     * @param totalXAmount The total amount of token X to be added.
+     * @param totalYAmount The total amount of token Y to be added.
+     * @param strategy The strategy for adding liquidity.
+     * @param owner The owner of the position.
+     * @param payer The payer of the transaction.
+     * @param slippagePercentage The slippage percentage for adding liquidity.
+     * @returns An object with two properties: `initPositionIxs` and `addLiquidityIxs`.
+     */
+    initializeMultiplePositionAndAddLiquidityByStrategy(positionKeypairGenerator: (count: number) => Promise<Keypair[]>, totalXAmount: BN$1, totalYAmount: BN$1, strategy: StrategyParameters, owner: PublicKey, payer: PublicKey, slippagePercentage: number): Promise<InitializeMultiplePositionAndAddLiquidityByStrategyResponse>;
+    /**
+     * Adds liquidity to an existing position using a specified strategy, allowing for chunkable transactions.
+     * If adding liquidity to bin out of position range, it will automatically expand. The limitation is 70 bins.
+     *
+     * @param {TInitializePositionAndAddLiquidityParamsByStrategy} params - The parameters required for adding liquidity.
+     * @param {PublicKey} params.positionPubKey - The public key of the position to which liquidity is being added.
+     * @param {BN} params.totalXAmount - The total amount of token X to be added as liquidity.
+     * @param {BN} params.totalYAmount - The total amount of token Y to be added as liquidity.
+     * @param {StrategyParameters} params.strategy - The strategy parameters for adding liquidity.
+     * @param {PublicKey} params.user - The public key of the user adding liquidity.
+     * @param {number} params.slippage - The slippage percentage allowed for the transaction.
+     *
+     * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions for adding liquidity.
+     */
+    addLiquidityByStrategyChunkable({ positionPubKey, totalXAmount, totalYAmount, strategy, user, slippage, }: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction[]>;
     /**
      * The function `initializePositionAndAddLiquidityByStrategy` function is used to initializes a position and adds liquidity
      * @param {TInitializePositionAndAddLiquidityParamsByStrategy}
@@ -10362,7 +10669,7 @@ declare class DLMM {
      */
     initializePositionAndAddLiquidityByWeight({ positionPubKey, totalXAmount, totalYAmount, xYAmountDistribution, user, slippage, }: TInitializePositionAndAddLiquidityParams): Promise<Transaction | Transaction[]>;
     /**
-     * The `addLiquidityByStrategy` function is used to add liquidity to existing position. It will chunk the bin range into multiple add liquidity transactions if it exceed max size.
+     * The `addLiquidityByStrategy` function is used to add liquidity to existing position
      * @param {TInitializePositionAndAddLiquidityParamsByStrategy}
      *    - `positionPubKey`: The public key of the position account. (usually use `new Keypair()`)
      *    - `totalXAmount`: The total amount of token X to be added to the liquidity pool.
@@ -10370,9 +10677,10 @@ declare class DLMM {
      *    - `strategy`: The strategy parameters to be used for the liquidity pool (Can use `calculateStrategyParameter` to calculate).
      *    - `user`: The public key of the user account.
      *    - `slippage`: The slippage percentage to be used for the liquidity pool.
-     * @returns {Promise<Transaction[]>} The function `addLiquidityByStrategy` returns a `Promise` that resolves to an array of transactions
+     * @returns {Promise<Transaction>} The function `addLiquidityByWeight` returns a `Promise` that resolves to either a single
+     * `Transaction` object
      */
-    addLiquidityByStrategy({ positionPubKey, totalXAmount, totalYAmount, strategy, user, slippage, }: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction[]>;
+    addLiquidityByStrategy({ positionPubKey, totalXAmount, totalYAmount, strategy, user, slippage, }: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction>;
     /**
      * @deprecated Use `addLiquidityByStrategy` instead which support both token and token2022.
      * The `addLiquidityByWeight` function is used to add liquidity to existing position
@@ -10687,7 +10995,10 @@ declare class DLMM {
      *
      * @returns An object containing the instructions to initialize new bin arrays and the instruction to rebalance the position.
      */
-    rebalancePosition(rebalancePositionResponse: RebalancePositionResponse, maxActiveBinSlippage: BN$1, rentPayer?: PublicKey, slippage?: number): Promise<TransactionInstruction[][]>;
+    rebalancePosition(rebalancePositionResponse: RebalancePositionResponse, maxActiveBinSlippage: BN$1, rentPayer?: PublicKey, slippage?: number): Promise<{
+        initBinArrayInstructions: TransactionInstruction[];
+        rebalancePositionInstruction: TransactionInstruction[];
+    }>;
     /**
      * Create an extended empty position.
      *
@@ -10713,7 +11024,10 @@ declare class DLMM {
     static updateReference(activeId: number, vParameter: vParameters, sParameter: sParameters, currentTimestamp: number): void;
     private createClaimBuildMethod;
     private createClaimSwapFeeMethod;
-    private getPotentialToken2022IxDataAndAccounts;
+    getPotentialToken2022IxDataAndAccounts(actionType: ActionType, rewardIndex?: number): {
+        slices: RemainingAccountsInfoSlice[];
+        accounts: AccountMeta[];
+    };
 }
 
 var address = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo";
@@ -21610,4 +21924,4 @@ declare const MAX_EXTRA_BIN_ARRAYS = 3;
 declare const U64_MAX: BN$1;
 declare const MAX_BINS_PER_POSITION: BN$1;
 
-export { ADMIN, AccountName, ActionType, ActivationType, BASIS_POINT_MAX, BIN_ARRAY_BITMAP_FEE, BIN_ARRAY_BITMAP_FEE_BN, BIN_ARRAY_BITMAP_SIZE, BIN_ARRAY_FEE, BIN_ARRAY_FEE_BN, Bin, BinAndAmount, BinArray, BinArrayAccount, BinArrayBitmapExtension, BinArrayBitmapExtensionAccount, BinLiquidity, BinLiquidityDistribution, BinLiquidityReduction, BitmapType, ClmmProgram, Clock, ClockLayout, CompressedBinDepositAmount, CompressedBinDepositAmounts, DEFAULT_BIN_PER_POSITION, DLMMError, DlmmSdkError, EXTENSION_BINARRAY_BITMAP_SIZE, EmissionRate, ExtendedPositionBinData, FEE_PRECISION, FeeInfo, GetOrCreateATAResponse, IAccountsCache, IDL, ILM_BASE, InitCustomizablePermissionlessPairIx, InitPermissionPairIx, LBCLMM_PROGRAM_IDS, LMRewards, LbClmm, LbPair, LbPairAccount, LbPosition, LiquidityOneSideParameter, LiquidityParameter, LiquidityParameterByStrategy, LiquidityParameterByStrategyOneSide, LiquidityParameterByWeight, MAX_ACTIVE_BIN_SLIPPAGE, MAX_BINS_PER_POSITION, MAX_BIN_ARRAY_SIZE, MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX, MAX_CLAIM_ALL_ALLOWED, MAX_EXTRA_BIN_ARRAYS, MAX_FEE_RATE, MAX_RESIZE_LENGTH, MEMO_PROGRAM_ID, Network, Opt, POOL_FEE, POOL_FEE_BN, POSITION_BIN_DATA_SIZE, POSITION_FEE, POSITION_FEE_BN, POSITION_MAX_LENGTH, POSITION_MIN_SIZE, PRECISION, PairLockInfo, PairStatus, PairType, Position, PositionBinData, PositionData, PositionInfo, PositionLockInfo, PositionV2, PositionVersion, PresetParameter, PresetParameter2, ProgramStrategyParameter, ProgramStrategyType, RebalanceAddLiquidityParam, RebalancePositionBinArrayRentalCostQuote, RebalancePositionResponse, RebalanceRemoveLiquidityParam, RemainingAccountInfo, RemainingAccountsInfoSlice, ResizeSide, ResizeSideEnum, RewardInfo, RewardInfos, SCALE, SCALE_OFFSET, SIMULATION_USER, SeedLiquidityCostBreakdown, SeedLiquidityResponse, SeedLiquiditySingleBinResponse, Strategy, StrategyParameters, StrategyType, SwapExactOutParams, SwapFee, SwapParams, SwapQuote, SwapQuoteExactOut, SwapWithPriceImpactParams, TInitializeMultiplePositionAndAddLiquidityParamsByStrategy, TInitializePositionAndAddLiquidityParams, TInitializePositionAndAddLiquidityParamsByStrategy, TOKEN_ACCOUNT_FEE, TOKEN_ACCOUNT_FEE_BN, TQuoteCreatePositionParams, TokenReserve, U64_MAX, UserFeeInfo, UserRewardInfo, autoFillXByStrategy, autoFillXByWeight, autoFillYByStrategy, autoFillYByWeight, binIdToBinArrayIndex, calculateBidAskDistribution, calculateNormalDistribution, calculateSpotDistribution, capSlippagePercentage, chunkedFetchMultipleBinArrayBitmapExtensionAccount, chunkedFetchMultiplePoolAccount, chunkedGetMultipleAccountInfos, chunks, computeFee, computeFeeFromAmount, computeProtocolFee, createProgram, decodeAccount, DLMM as default, deriveBinArray, deriveBinArrayBitmapExtension, deriveCustomizablePermissionlessLbPair, deriveEventAuthority, deriveLbPair, deriveLbPair2, deriveLbPairWithPresetParamWithIndexKey, deriveOracle, derivePermissionLbPair, derivePosition, derivePresetParameter, derivePresetParameter2, derivePresetParameterWithIndex, deriveReserve, deriveRewardVault, deriveTokenBadge, enumerateBins, findNextBinArrayIndexWithLiquidity, findNextBinArrayWithLiquidity, fromWeightDistributionToAmount, fromWeightDistributionToAmountOneSide, getAccountDiscriminator, getBaseFee, getBinArrayLowerUpperBinId, getBinArraysRequiredByPositionRange, getBinFromBinArray, getBinIdIndexInBinArray, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getOrCreateATAInstruction, getOutAmount, getPriceOfBinByBinId, getTokenBalance, getTokenDecimals, getTokenProgramId, getTokensMintFromPoolAddress, getTotalFee, getVariableFee, isBinIdWithinBinArray, isOverflowDefaultBinArrayBitmap, parseLogs, range, sParameters, swapExactInQuoteAtBin, swapExactOutQuoteAtBin, toAmountAskSide, toAmountBidSide, toAmountBothSide, toAmountsBothSideByStrategy, toStrategyParameters, toWeightDistribution, unwrapSOLInstruction, updateBinArray, vParameters, wrapSOLInstruction };
+export { ADMIN, AccountName, ActionType, ActivationType, AmountIntoBin, BASIS_POINT_MAX, BIN_ARRAY_BITMAP_FEE, BIN_ARRAY_BITMAP_FEE_BN, BIN_ARRAY_BITMAP_SIZE, BIN_ARRAY_FEE, BIN_ARRAY_FEE_BN, BidAskParameters, Bin, BinAndAmount, BinArray, BinArrayAccount, BinArrayBitmapExtension, BinArrayBitmapExtensionAccount, BinLiquidity, BinLiquidityDistribution, BinLiquidityReduction, BitmapType, ClmmProgram, Clock, ClockLayout, CompressedBinDepositAmount, CompressedBinDepositAmounts, CreateRebalancePositionParams, DEFAULT_BIN_PER_POSITION, DLMMError, DlmmSdkError, EXTENSION_BINARRAY_BITMAP_SIZE, EmissionRate, ExtendedPositionBinData, FEE_PRECISION, FeeInfo, GetOrCreateATAResponse, IAccountsCache, IDL, ILM_BASE, IPosition, InitCustomizablePermissionlessPairIx, InitPermissionPairIx, InitializeMultiplePositionAndAddLiquidityByStrategyResponse, LBCLMM_PROGRAM_IDS, LMRewards, LbClmm, LbPair, LbPairAccount, LbPosition, 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_CLAIM_ALL_ALLOWED, MAX_EXTRA_BIN_ARRAYS, MAX_FEE_RATE, MAX_RESIZE_LENGTH, MEMO_PROGRAM_ID, Network, Opt, POOL_FEE, POOL_FEE_BN, POSITION_BIN_DATA_SIZE, POSITION_FEE, POSITION_FEE_BN, POSITION_MAX_LENGTH, POSITION_MIN_SIZE, PRECISION, PairLockInfo, PairStatus, PairType, Position, PositionBinData, PositionData, PositionInfo, PositionLockInfo, PositionV2, PositionV2Wrapper, PositionVersion, PresetParameter, PresetParameter2, ProgramStrategyParameter, ProgramStrategyType, RebalanceAddLiquidityParam, RebalancePosition, RebalancePositionBinArrayRentalCostQuote, RebalancePositionResponse, RebalanceRemoveLiquidityParam, RebalanceWithDeposit, RebalanceWithWithdraw, RemainingAccountInfo, RemainingAccountsInfoSlice, ResizeSide, ResizeSideEnum, RewardInfo, RewardInfos, SCALE, SCALE_OFFSET, SIMULATION_USER, SeedLiquidityCostBreakdown, SeedLiquidityResponse, SeedLiquiditySingleBinResponse, SimulateRebalanceResp, Strategy, StrategyParameters, StrategyType, SwapExactOutParams, SwapFee, SwapParams, SwapQuote, SwapQuoteExactOut, SwapWithPriceImpactParams, TInitializeMultiplePositionAndAddLiquidityParamsByStrategy, TInitializePositionAndAddLiquidityParams, TInitializePositionAndAddLiquidityParamsByStrategy, TOKEN_ACCOUNT_FEE, TOKEN_ACCOUNT_FEE_BN, TQuoteCreatePositionParams, TokenReserve, U64_MAX, UserFeeInfo, UserRewardInfo, autoFillXByStrategy, autoFillXByWeight, autoFillYByStrategy, autoFillYByWeight, binIdToBinArrayIndex, buildBitFlagAndNegateStrategyParameters, buildLiquidityStrategyParameters, calculateBidAskDistribution, calculateNormalDistribution, calculatePositionSize, calculateSpotDistribution, capSlippagePercentage, chunkBinRange, chunkBinRangeIntoExtendedPositions, chunkDepositWithRebalanceEndpoint, chunkPositionBinRange, chunkedFetchMultipleBinArrayBitmapExtensionAccount, chunkedFetchMultiplePoolAccount, chunkedGetMultipleAccountInfos, chunks, computeFee, computeFeeFromAmount, computeProtocolFee, createProgram, decodeAccount, decodeExtendedPosition, DLMM as default, deriveBinArray, deriveBinArrayBitmapExtension, deriveCustomizablePermissionlessLbPair, deriveEventAuthority, deriveLbPair, deriveLbPair2, deriveLbPairWithPresetParamWithIndexKey, deriveOracle, derivePermissionLbPair, derivePlaceHolderAccountMeta, derivePosition, derivePresetParameter, derivePresetParameter2, derivePresetParameterWithIndex, deriveReserve, deriveRewardVault, deriveTokenBadge, enumerateBins, findNextBinArrayIndexWithLiquidity, findNextBinArrayWithLiquidity, fromWeightDistributionToAmount, fromWeightDistributionToAmountOneSide, getAccountDiscriminator, getAmountInBinsAskSide, getAmountInBinsBidSide, getAndCapMaxActiveBinSlippage, getAutoFillAmountByRebalancedPosition, getBaseFee, getBinArrayAccountMetasCoverage, getBinArrayIndexesCoverage, getBinArrayKeysCoverage, getBinArrayLowerUpperBinId, getBinArraysRequiredByPositionRange, getBinCount, getBinFromBinArray, getBinIdIndexInBinArray, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getExtendedPositionBinCount, getLiquidityStrategyParameterBuilder, getOrCreateATAInstruction, getOutAmount, getPositionCountByBinCount, getPositionExpandRentExemption, getPositionLowerUpperBinIdWithLiquidity, getPositionRentExemption, getPriceOfBinByBinId, getRebalanceBinArrayIndexesAndBitmapCoverage, getSlippageMaxAmount, getSlippageMinAmount, getTokenBalance, getTokenDecimals, getTokenProgramId, getTokensMintFromPoolAddress, getTotalFee, getVariableFee, isBinIdWithinBinArray, isOverflowDefaultBinArrayBitmap, isPositionNoFee, isPositionNoReward, parseLogs, range, resetUninvolvedLiquidityParams, sParameters, suggestBalancedXParametersFromY, suggestBalancedYParametersFromX, swapExactInQuoteAtBin, swapExactOutQuoteAtBin, toAmountAskSide, toAmountBidSide, toAmountBothSide, toAmountIntoBins, toAmountsBothSideByStrategy, toStrategyParameters, toWeightDistribution, unwrapSOLInstruction, updateBinArray, vParameters, wrapPosition, wrapSOLInstruction };