@meteora-ag/dlmm 1.9.0-rc.2 → 1.9.0-rc.3

package/dist/index.d.ts

@@ -1,65 +1,12 @@
 import * as _coral_xyz_anchor from '@coral-xyz/anchor';
-import { BN, Program, IdlAccounts, ProgramAccount, IdlTypes, EventParser } 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, AccountInfo, Transaction, GetProgramAccountsFilter } 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$1 from 'bn.js';
-
-declare const LBCLMM_PROGRAM_IDS: {
-    devnet: string;
-    localhost: string;
-    "mainnet-beta": string;
-};
-declare const ALT_ADDRESS: {
-    "mainnet-beta": string;
-    devnet: string;
-};
-declare const ADMIN: {
-    devnet: string;
-    localhost: string;
-};
-declare enum Network {
-    MAINNET = "mainnet-beta",
-    TESTNET = "testnet",
-    DEVNET = "devnet",
-    LOCAL = "localhost"
-}
-declare const BASIS_POINT_MAX = 10000;
-declare const SCALE_OFFSET = 64;
-declare const SCALE: BN;
-declare const FEE_PRECISION: BN;
-declare const MAX_FEE_RATE: BN;
-declare const BIN_ARRAY_FEE = 0.07143744;
-declare const POSITION_FEE = 0.05740608;
-declare const TOKEN_ACCOUNT_FEE = 0.00203928;
-declare const POOL_FEE = 0.00718272;
-declare const BIN_ARRAY_BITMAP_FEE = 0.01180416;
-declare const BIN_ARRAY_FEE_BN: BN;
-declare const POSITION_FEE_BN: BN;
-declare const TOKEN_ACCOUNT_FEE_BN: BN;
-declare const POOL_FEE_BN: BN;
-declare const BIN_ARRAY_BITMAP_FEE_BN: BN;
-declare const MAX_BIN_ARRAY_SIZE: BN;
-declare const DEFAULT_BIN_PER_POSITION: BN;
-declare const BIN_ARRAY_BITMAP_SIZE: BN;
-declare const EXTENSION_BINARRAY_BITMAP_SIZE: BN;
-declare const POSITION_MAX_LENGTH: BN;
-declare const MAX_RESIZE_LENGTH: BN;
-declare const SIMULATION_USER: PublicKey;
-declare const PRECISION = 18446744073709552000;
-declare const MAX_CLAIM_ALL_ALLOWED = 2;
-declare const MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX = 26;
-declare const MAX_ACTIVE_BIN_SLIPPAGE = 3;
-declare const ILM_BASE: PublicKey;
-declare const MAX_EXTRA_BIN_ARRAYS = 3;
-declare const U64_MAX: BN;
-declare const MAX_BINS_PER_POSITION: BN;
-declare enum FunctionType {
-    LiquidityMining = 0
-}
+import BN from 'bn.js';
 
 /**
  * Program IDL in camelCase format in order to be used in JS/TS.
@@ -9424,33 +9371,33 @@ type LbClmm = {
     ];
 };
 
-declare function buildBitFlagAndNegateStrategyParameters(x0: BN$1, y0: BN$1, deltaX: BN$1, deltaY: BN$1): {
+declare function buildBitFlagAndNegateStrategyParameters(x0: BN, y0: BN, deltaX: BN, deltaY: BN): {
     bitFlag: number;
-    x0: BN$1;
-    y0: BN$1;
-    deltaX: BN$1;
-    deltaY: BN$1;
+    x0: BN;
+    y0: BN;
+    deltaX: BN;
+    deltaY: BN;
 };
 interface AmountIntoBin {
-    binId: BN$1;
-    amountX: BN$1;
-    amountY: BN$1;
+    binId: BN;
+    amountX: BN;
+    amountY: BN;
 }
-declare function getAmountInBinsBidSide(activeId: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, deltaY: BN$1, y0: BN$1): AmountIntoBin[];
-declare function getAmountInBinsAskSide(activeId: BN$1, binStep: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, deltaX: BN$1, x0: BN$1): AmountIntoBin[];
-declare function toAmountIntoBins(activeId: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, deltaX: BN$1, deltaY: BN$1, x0: BN$1, y0: BN$1, binStep: BN$1, favorXInActiveBin: boolean): AmountIntoBin[];
+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$1;
-    liquidityAndFeeYWithdrawn: BN$1;
-    rewardsAmountClaimed: BN$1[];
+    liquidityAndFeeXWithdrawn: BN;
+    liquidityAndFeeYWithdrawn: BN;
+    rewardsAmountClaimed: BN[];
 }
 interface SimulateDepositResult {
-    totalAmountXDeposited: BN$1;
-    totalAmountYDeposited: BN$1;
-    actualTotalAmountXDeposited: BN$1;
-    actualTotalAmountYDeposited: BN$1;
-    actualLiquidityAndFeeXWithdrawn: BN$1;
-    actualLiquidityAndFeeYWithdrawn: BN$1;
+    totalAmountXDeposited: BN;
+    totalAmountYDeposited: BN;
+    actualTotalAmountXDeposited: BN;
+    actualTotalAmountYDeposited: BN;
+    actualLiquidityAndFeeXWithdrawn: BN;
+    actualLiquidityAndFeeYWithdrawn: BN;
 }
 interface CreateRebalancePositionParams {
     program: Program<LbClmm>;
@@ -9462,109 +9409,109 @@ interface CreateRebalancePositionParams {
 }
 declare class RebalancePosition {
     address: PublicKey;
-    lowerBinId: BN$1;
-    upperBinId: BN$1;
+    lowerBinId: BN;
+    upperBinId: BN;
     lbPair: LbPair;
     owner: PublicKey;
     shouldClaimFee: boolean;
     shouldClaimReward: boolean;
     rebalancePositionBinData: RebalancePositionBinData[];
     activeBin: Bin | null;
-    currentTimestamp: BN$1;
-    constructor(positionAddress: PublicKey, positionData: PositionData, lbPair: LbPair, activeBin: Bin | null, shouldClaimFee: boolean, shouldClaimReward: boolean, currentTimestamp: BN$1);
+    currentTimestamp: BN;
+    constructor(positionAddress: PublicKey, positionData: PositionData, lbPair: LbPair, activeBin: Bin | null, shouldClaimFee: boolean, shouldClaimReward: boolean, currentTimestamp: BN);
     static create(params: CreateRebalancePositionParams): Promise<RebalancePosition>;
-    _simulateDeposit(binStep: BN$1, tokenXDecimal: BN$1, tokenYDecimal: BN$1, deposits: RebalanceWithDeposit[], simulatedWithdrawResult: SimulateWithdrawResult): {
+    _simulateDeposit(binStep: BN, tokenXDecimal: BN, tokenYDecimal: BN, deposits: RebalanceWithDeposit[], simulatedWithdrawResult: SimulateWithdrawResult): {
         result: SimulateDepositResult;
         depositParams: RebalanceAddLiquidityParam[];
     };
-    _simulateResize(depositMinBinId: BN$1, depositMaxBinId: BN$1, binStep: BN$1, tokenXDecimal: BN$1, tokenYDecimal: BN$1): void;
+    _simulateResize(depositMinBinId: BN, depositMaxBinId: BN, binStep: BN, tokenXDecimal: BN, tokenYDecimal: BN): void;
     _simulateWithdraw(withdraws: RebalanceWithWithdraw[]): {
         result: SimulateWithdrawResult;
         withdrawParams: RebalanceRemoveLiquidityParam[];
     };
-    simulateRebalance(connection: Connection, binStep: BN$1, tokenXDecimal: BN$1, tokenYDecimal: BN$1, withdraws: RebalanceWithWithdraw[], deposits: RebalanceWithDeposit[]): Promise<SimulateRebalanceResp>;
-    totalAmounts(): BN$1[];
-    totalFeeAmounts(): BN$1[];
-    totalRewardAmounts(): BN$1[];
+    simulateRebalance(connection: Connection, binStep: BN, tokenXDecimal: BN, tokenYDecimal: BN, withdraws: RebalanceWithWithdraw[], deposits: RebalanceWithDeposit[]): Promise<SimulateRebalanceResp>;
+    totalAmounts(): BN[];
+    totalFeeAmounts(): BN[];
+    totalRewardAmounts(): BN[];
 }
 interface RebalancePositionBinData {
     binId: number;
     price: string;
     pricePerToken: string;
-    amountX: BN$1;
-    amountY: BN$1;
-    claimableRewardAmount: BN$1[];
-    claimableFeeXAmount: BN$1;
-    claimableFeeYAmount: BN$1;
+    amountX: BN;
+    amountY: BN;
+    claimableRewardAmount: BN[];
+    claimableFeeXAmount: BN;
+    claimableFeeYAmount: BN;
 }
 interface RebalanceWithDeposit {
-    minDeltaId: BN$1;
-    maxDeltaId: BN$1;
-    x0: BN$1;
-    y0: BN$1;
-    deltaX: BN$1;
-    deltaY: BN$1;
+    minDeltaId: BN;
+    maxDeltaId: BN;
+    x0: BN;
+    y0: BN;
+    deltaX: BN;
+    deltaY: BN;
     favorXInActiveBin: boolean;
 }
 interface RebalanceWithWithdraw {
-    minBinId: BN$1 | null;
-    maxBinId: BN$1 | null;
-    bps: BN$1;
+    minBinId: BN | null;
+    maxBinId: BN | null;
+    bps: BN;
 }
 interface SimulateRebalanceResp {
-    amountXDeposited: BN$1;
-    amountYDeposited: BN$1;
-    actualAmountXDeposited: BN$1;
-    actualAmountYDeposited: BN$1;
-    actualAmountXWithdrawn: BN$1;
-    actualAmountYWithdrawn: BN$1;
-    rewardAmountsClaimed: BN$1[];
+    amountXDeposited: BN;
+    amountYDeposited: BN;
+    actualAmountXDeposited: BN;
+    actualAmountYDeposited: BN;
+    actualAmountXWithdrawn: BN;
+    actualAmountYWithdrawn: BN;
+    rewardAmountsClaimed: BN[];
     depositParams: RebalanceAddLiquidityParam[];
     withdrawParams: RebalanceRemoveLiquidityParam[];
-    rentalCostLamports: BN$1;
+    rentalCostLamports: BN;
 }
 declare function getRebalanceBinArrayIndexesAndBitmapCoverage(adds: RebalanceAddLiquidityParam[], removes: RebalanceRemoveLiquidityParam[], activeId: number, pairAddress: PublicKey, programId: PublicKey): {
-    binArrayIndexes: BN$1[];
+    binArrayIndexes: BN[];
     binArrayBitmap: PublicKey;
 };
 
 interface LiquidityStrategyParameters {
-    x0: BN$1;
-    y0: BN$1;
-    deltaX: BN$1;
-    deltaY: BN$1;
+    x0: BN;
+    y0: BN;
+    deltaX: BN;
+    deltaY: BN;
 }
 interface BidAskParameters {
-    base: BN$1;
-    delta: BN$1;
+    base: BN;
+    delta: BN;
 }
 interface LiquidityStrategyParameterBuilder {
-    findXParameters(amountX: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, binStep: BN$1, activeId: BN$1): BidAskParameters;
-    findYParameters(amountY: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, activeId: BN$1): BidAskParameters;
-    suggestBalancedXParametersFromY(activeId: BN$1, binStep: BN$1, favorXInActiveBin: boolean, minDeltaId: BN$1, maxDeltaId: BN$1, amountY: BN$1): BidAskParameters & {
-        amountX: BN$1;
+    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$1, binStep: BN$1, favorXInActiveBin: boolean, minDeltaId: BN$1, maxDeltaId: BN$1, amountXInQuoteValue: BN$1): BidAskParameters & {
-        amountY: BN$1;
+    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$1, deltaY: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, activeId: BN$1, binStep: BN$1, favorXInActiveBin: boolean, builder: LiquidityStrategyParameterBuilder): BidAskParameters & {
-    amountX: BN$1;
+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$1;
+    amount: BN;
     isBidSide: boolean;
 };
-declare function suggestBalancedYParametersFromX(x0: BN$1, deltaX: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, activeId: BN$1, binStep: BN$1, favorXInActiveBin: boolean, builder: LiquidityStrategyParameterBuilder): BidAskParameters & {
-    amountY: BN$1;
+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$1, amountY: BN$1, minDeltaId: BN$1, maxDeltaId: BN$1, binStep: BN$1, favorXInActiveId: boolean, activeId: BN$1, strategyParameterBuilder: LiquidityStrategyParameterBuilder): LiquidityStrategyParameters;
+declare function buildLiquidityStrategyParameters(amountX: BN, amountY: BN, minDeltaId: BN, maxDeltaId: BN, binStep: BN, favorXInActiveId: boolean, activeId: BN, strategyParameterBuilder: LiquidityStrategyParameterBuilder): LiquidityStrategyParameters;
 
 interface BinAndAmount {
     binId: number;
-    xAmountBpsOfTotal: BN;
-    yAmountBpsOfTotal: BN;
+    xAmountBpsOfTotal: BN$1;
+    yAmountBpsOfTotal: BN$1;
 }
 interface TokenReserve {
     publicKey: PublicKey;
@@ -9639,12 +9586,12 @@ interface EmissionRate {
     rewardTwo: Decimal | undefined;
 }
 interface SwapFee {
-    feeX: BN;
-    feeY: BN;
+    feeX: BN$1;
+    feeY: BN$1;
 }
 interface LMRewards {
-    rewardOne: BN;
-    rewardTwo: BN;
+    rewardOne: BN$1;
+    rewardTwo: BN$1;
 }
 declare enum PositionVersion {
     V1 = 0,
@@ -9702,16 +9649,16 @@ interface TQuoteCreatePositionParams {
 }
 interface TInitializePositionAndAddLiquidityParams {
     positionPubKey: PublicKey;
-    totalXAmount: BN;
-    totalYAmount: BN;
+    totalXAmount: BN$1;
+    totalYAmount: BN$1;
     xYAmountDistribution: BinAndAmount[];
     user: PublicKey;
     slippage?: number;
 }
 interface TInitializePositionAndAddLiquidityParamsByStrategy {
     positionPubKey: PublicKey;
-    totalXAmount: BN;
-    totalYAmount: BN;
+    totalXAmount: BN$1;
+    totalYAmount: BN$1;
     strategy: StrategyParameters;
     user: PublicKey;
     slippage?: number;
@@ -9732,8 +9679,8 @@ interface InitializeMultiplePositionAndAddLiquidityByStrategyResponse2 {
     lookupTableAddress?: PublicKey;
 }
 interface TInitializeMultiplePositionAndAddLiquidityParamsByStrategy {
-    totalXAmount: BN;
-    totalYAmount: BN;
+    totalXAmount: BN$1;
+    totalYAmount: BN$1;
     strategy: StrategyParameters;
     user: PublicKey;
     slippage?: number;
@@ -9741,37 +9688,37 @@ interface TInitializeMultiplePositionAndAddLiquidityParamsByStrategy {
 }
 interface BinLiquidity {
     binId: number;
-    xAmount: BN;
-    yAmount: BN;
-    supply: BN;
+    xAmount: BN$1;
+    yAmount: BN$1;
+    supply: BN$1;
     version: number;
     price: string;
     pricePerToken: string;
-    feeAmountXPerTokenStored: BN;
-    feeAmountYPerTokenStored: BN;
-    rewardPerTokenStored: BN[];
+    feeAmountXPerTokenStored: BN$1;
+    feeAmountYPerTokenStored: BN$1;
+    rewardPerTokenStored: BN$1[];
 }
 declare namespace BinLiquidity {
     function fromBin(bin: Bin, binId: number, binStep: number, baseTokenDecimal: number, quoteTokenDecimal: number, version: number): BinLiquidity;
     function empty(binId: number, binStep: number, baseTokenDecimal: number, quoteTokenDecimal: number, version: number): BinLiquidity;
 }
 interface SwapQuote {
-    consumedInAmount: BN;
-    outAmount: BN;
-    fee: BN;
-    protocolFee: BN;
-    minOutAmount: BN;
+    consumedInAmount: BN$1;
+    outAmount: BN$1;
+    fee: BN$1;
+    protocolFee: BN$1;
+    minOutAmount: BN$1;
     priceImpact: Decimal;
     binArraysPubkey: any[];
     endPrice: Decimal;
 }
 interface SwapQuoteExactOut {
-    inAmount: BN;
-    outAmount: BN;
-    fee: BN;
+    inAmount: BN$1;
+    outAmount: BN$1;
+    fee: BN$1;
     priceImpact: Decimal;
-    protocolFee: BN;
-    maxInAmount: BN;
+    protocolFee: BN$1;
+    maxInAmount: BN$1;
     binArraysPubkey: any[];
 }
 interface IAccountsCache {
@@ -9796,22 +9743,22 @@ interface PositionData {
     totalXAmount: string;
     totalYAmount: string;
     positionBinData: PositionBinData[];
-    lastUpdatedAt: BN;
+    lastUpdatedAt: BN$1;
     upperBinId: number;
     lowerBinId: number;
-    feeX: BN;
-    feeY: BN;
-    rewardOne: BN;
-    rewardTwo: BN;
+    feeX: BN$1;
+    feeY: BN$1;
+    rewardOne: BN$1;
+    rewardTwo: BN$1;
     feeOwner: PublicKey;
-    totalClaimedFeeXAmount: BN;
-    totalClaimedFeeYAmount: BN;
-    feeXExcludeTransferFee: BN;
-    feeYExcludeTransferFee: BN;
-    rewardOneExcludeTransferFee: BN;
-    rewardTwoExcludeTransferFee: BN;
-    totalXAmountExcludeTransferFee: BN;
-    totalYAmountExcludeTransferFee: BN;
+    totalClaimedFeeXAmount: BN$1;
+    totalClaimedFeeYAmount: BN$1;
+    feeXExcludeTransferFee: BN$1;
+    feeYExcludeTransferFee: BN$1;
+    rewardOneExcludeTransferFee: BN$1;
+    rewardTwoExcludeTransferFee: BN$1;
+    totalXAmountExcludeTransferFee: BN$1;
+    totalYAmountExcludeTransferFee: BN$1;
     owner: PublicKey;
 }
 interface SwapWithPriceImpactParams {
@@ -9826,11 +9773,11 @@ interface SwapWithPriceImpactParams {
     /**
      * in token amount
      */
-    inAmount: BN;
+    inAmount: BN$1;
     /**
      * price impact in bps
      */
-    priceImpact: BN;
+    priceImpact: BN$1;
     /**
      * desired lbPair to swap against
      */
@@ -9853,11 +9800,11 @@ interface SwapParams {
     /**
      * in token amount
      */
-    inAmount: BN;
+    inAmount: BN$1;
     /**
      * minimum out with slippage
      */
-    minOutAmount: BN;
+    minOutAmount: BN$1;
     /**
      * desired lbPair to swap against
      */
@@ -9880,11 +9827,11 @@ interface SwapExactOutParams {
     /**
      * out token amount
      */
-    outAmount: BN;
+    outAmount: BN$1;
     /**
      * maximum in amount, also known as slippage
      */
-    maxInAmount: BN;
+    maxInAmount: BN$1;
     /**
      * desired lbPair to swap against
      */
@@ -9914,19 +9861,19 @@ interface SeedLiquiditySingleBinResponse {
     costBreakdown: SeedLiquidityCostBreakdown;
 }
 interface SeedLiquidityCostBreakdown {
-    tokenOwnerProveAssociatedTokenAccountLamports: BN;
-    totalPositionLamports: BN;
-    totalBinArraysLamports: BN;
-    totalPositionCount: BN;
-    totalBinArraysCount: BN;
-    binArrayBitmapLamports: BN;
+    tokenOwnerProveAssociatedTokenAccountLamports: BN$1;
+    totalPositionLamports: BN$1;
+    totalBinArraysLamports: BN$1;
+    totalPositionCount: BN$1;
+    totalBinArraysCount: BN$1;
+    binArrayBitmapLamports: BN$1;
 }
 interface Clock {
-    slot: BN;
-    epochStartTimestamp: BN;
-    epoch: BN;
-    leaderScheduleEpoch: BN;
-    unixTimestamp: BN;
+    slot: BN$1;
+    epochStartTimestamp: BN$1;
+    epoch: BN$1;
+    leaderScheduleEpoch: BN$1;
+    unixTimestamp: BN$1;
 }
 declare const ClockLayout: any;
 declare enum PairStatus {
@@ -9965,14 +9912,14 @@ interface RebalancePositionBinArrayRentalCostQuote {
 declare const REBALANCE_POSITION_PADDING: any[];
 
 /** private */
-declare function isOverflowDefaultBinArrayBitmap(binArrayIndex: BN): boolean;
+declare function isOverflowDefaultBinArrayBitmap(binArrayIndex: BN$1): boolean;
 declare function deriveBinArrayBitmapExtension(lbPair: PublicKey, programId: PublicKey): [PublicKey, number];
-declare function binIdToBinArrayIndex(binId: BN): BN;
-declare function getBinArrayLowerUpperBinId(binArrayIndex: BN): BN[];
-declare function isBinIdWithinBinArray(activeId: BN, binArrayIndex: BN): boolean;
+declare function binIdToBinArrayIndex(binId: BN$1): BN$1;
+declare function getBinArrayLowerUpperBinId(binArrayIndex: BN$1): BN$1[];
+declare function isBinIdWithinBinArray(activeId: BN$1, binArrayIndex: BN$1): boolean;
 declare function getBinFromBinArray(binId: number, binArray: BinArray): Bin;
-declare function findNextBinArrayIndexWithLiquidity(swapForY: boolean, activeId: BN, lbPairState: LbPair, binArrayBitmapExtension: BinArrayBitmapExtension | null): BN | null;
-declare function findNextBinArrayWithLiquidity(swapForY: boolean, activeBinId: BN, lbPairState: LbPair, binArrayBitmapExtension: BinArrayBitmapExtension | null, binArrays: BinArrayAccount[]): BinArrayAccount | null;
+declare function findNextBinArrayIndexWithLiquidity(swapForY: boolean, activeId: BN$1, lbPairState: LbPair, binArrayBitmapExtension: BinArrayBitmapExtension | null): BN$1 | null;
+declare function findNextBinArrayWithLiquidity(swapForY: boolean, activeBinId: BN$1, lbPairState: LbPair, binArrayBitmapExtension: BinArrayBitmapExtension | null, binArrays: BinArrayAccount[]): BinArrayAccount | null;
 /**
  * Retrieves the bin arrays required to initialize multiple positions in continuous range.
  *
@@ -9981,27 +9928,27 @@ declare function findNextBinArrayWithLiquidity(swapForY: boolean, activeBinId: B
  * @param {BN} toBinId - The ending bin ID.
  * @return {[{key: PublicKey, index: BN }]} An array of bin arrays required for the given position range.
  */
-declare function getBinArraysRequiredByPositionRange(pair: PublicKey, fromBinId: BN, toBinId: BN, programId: PublicKey): {
+declare function getBinArraysRequiredByPositionRange(pair: PublicKey, fromBinId: BN$1, toBinId: BN$1, programId: PublicKey): {
     key: PublicKey;
-    index: BN;
+    index: BN$1;
 }[];
 declare function enumerateBins(binsById: Map<number, Bin>, lowerBinId: number, upperBinId: number, binStep: number, baseTokenDecimal: number, quoteTokenDecimal: number, version: number): Generator<BinLiquidity, void, unknown>;
-declare function getBinIdIndexInBinArray(binId: BN, lowerBinId: BN, upperBinId: BN): BN;
-declare function updateBinArray(activeId: BN, clock: Clock, allRewardInfos: RewardInfos, binArray: BinArray): {
-    index: BN;
+declare function getBinIdIndexInBinArray(binId: BN$1, lowerBinId: BN$1, upperBinId: BN$1): BN$1;
+declare function updateBinArray(activeId: BN$1, clock: Clock, allRewardInfos: RewardInfos, binArray: BinArray): {
+    index: BN$1;
     version: number;
     padding1: number[];
     lbPair: PublicKey;
     bins: {
-        amountX: BN;
-        amountY: BN;
-        price: BN;
-        liquiditySupply: BN;
-        functionBytes: BN[];
-        feeAmountXPerTokenStored: BN;
-        feeAmountYPerTokenStored: BN;
-        padding0: BN;
-        padding1: BN;
+        amountX: BN$1;
+        amountY: BN$1;
+        price: BN$1;
+        liquiditySupply: BN$1;
+        functionBytes: BN$1[];
+        feeAmountXPerTokenStored: BN$1;
+        feeAmountYPerTokenStored: BN$1;
+        padding0: BN$1;
+        padding1: BN$1;
     }[];
 };
 declare function binDeltaToMinMaxBinId(binDelta: number, activeBinId: number): {
@@ -10010,49 +9957,49 @@ declare function binDeltaToMinMaxBinId(binDelta: number, activeBinId: number): {
 };
 
 /** private */
-declare function derivePresetParameterWithIndex(index: BN, programId: PublicKey): [PublicKey, number];
+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, programId: PublicKey): [PublicKey, number];
-declare function derivePresetParameter2(binStep: BN, baseFactor: BN, programId: PublicKey): [PublicKey, number];
-declare function deriveLbPair2(tokenX: PublicKey, tokenY: PublicKey, binStep: BN, baseFactor: BN, programId: PublicKey): [PublicKey, number];
+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, programId: PublicKey): [PublicKey, number];
+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, 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, width: BN, programId: PublicKey): [PublicKey, number];
-declare function deriveBinArray(lbPair: PublicKey, index: BN, 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, programId: PublicKey): [PublicKey, number];
+declare function deriveRewardVault(lbPair: PublicKey, rewardIndex: BN$1, programId: PublicKey): [PublicKey, number];
 declare function derivePlaceHolderAccountMeta(programId: PublicKey): AccountMeta;
 declare function deriveOperator(whitelistedSigner: PublicKey, programId: PublicKey): PublicKey;
 
-declare function getBaseFee(binStep: number, sParameter: sParameters): BN;
-declare function getVariableFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN;
-declare function getTotalFee(binStep: number, sParameter: sParameters, vParameter: vParameters): BN;
-declare function computeFee(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmount: BN): BN;
-declare function computeFeeFromAmount(binStep: number, sParameter: sParameters, vParameter: vParameters, inAmountWithFees: BN): BN;
-declare function computeProtocolFee(feeAmount: BN, sParameter: sParameters): BN;
-declare function swapExactOutQuoteAtBin(bin: Bin, binStep: number, sParameter: sParameters, vParameter: vParameters, outAmount: BN, swapForY: boolean): {
-    amountIn: BN;
-    amountOut: BN;
-    fee: BN;
-    protocolFee: BN;
+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, swapForY: boolean): {
-    amountIn: BN;
-    amountOut: BN;
-    fee: BN;
-    protocolFee: BN;
+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;
 };
 
 /**
@@ -10075,27 +10022,27 @@ declare function getTokenProgramId(lbPairState: LbPair): {
 
 interface IPosition {
     address(): PublicKey;
-    lowerBinId(): BN$1;
-    upperBinId(): BN$1;
-    liquidityShares(): BN$1[];
+    lowerBinId(): BN;
+    upperBinId(): BN;
+    liquidityShares(): BN[];
     rewardInfos(): UserRewardInfo[];
     feeInfos(): UserFeeInfo[];
-    lastUpdatedAt(): BN$1;
+    lastUpdatedAt(): BN;
     lbPair(): PublicKey;
-    totalClaimedFeeXAmount(): BN$1;
-    totalClaimedFeeYAmount(): BN$1;
-    totalClaimedRewards(): BN$1[];
+    totalClaimedFeeXAmount(): BN;
+    totalClaimedFeeYAmount(): BN;
+    totalClaimedRewards(): BN[];
     operator(): PublicKey;
-    lockReleasePoint(): BN$1;
+    lockReleasePoint(): BN;
     feeOwner(): PublicKey;
     owner(): PublicKey;
-    getBinArrayIndexesCoverage(): BN$1[];
+    getBinArrayIndexesCoverage(): BN[];
     getBinArrayKeysCoverage(programId: PublicKey): PublicKey[];
     version(): PositionVersion;
-    width(): BN$1;
+    width(): BN;
 }
 interface CombinedPositionBinData {
-    liquidityShares: BN$1[];
+    liquidityShares: BN[];
     rewardInfos: UserRewardInfo[];
     feeInfos: UserFeeInfo[];
 }
@@ -10107,32 +10054,32 @@ declare class PositionV2Wrapper implements IPosition {
     combinedPositionBinData: CombinedPositionBinData;
     constructor(positionAddress: PublicKey, inner: PositionV2, extended: ExtendedPositionBinData[], combinedPositionBinData: CombinedPositionBinData);
     address(): PublicKey;
-    totalClaimedRewards(): BN$1[];
+    totalClaimedRewards(): BN[];
     feeOwner(): PublicKey;
-    lockReleasePoint(): BN$1;
+    lockReleasePoint(): BN;
     operator(): PublicKey;
-    totalClaimedFeeYAmount(): BN$1;
-    totalClaimedFeeXAmount(): BN$1;
+    totalClaimedFeeYAmount(): BN;
+    totalClaimedFeeXAmount(): BN;
     lbPair(): PublicKey;
-    lowerBinId(): BN$1;
-    upperBinId(): BN$1;
-    liquidityShares(): BN$1[];
+    lowerBinId(): BN;
+    upperBinId(): BN;
+    liquidityShares(): BN[];
     rewardInfos(): UserRewardInfo[];
     feeInfos(): UserFeeInfo[];
-    lastUpdatedAt(): BN$1;
-    getBinArrayIndexesCoverage(): BN$1[];
+    lastUpdatedAt(): BN;
+    getBinArrayIndexesCoverage(): BN[];
     getBinArrayKeysCoverage(programId: PublicKey): PublicKey[];
     version(): PositionVersion;
     owner(): PublicKey;
-    width(): BN$1;
+    width(): BN;
 }
 
-declare function getBinArrayIndexesCoverage(lowerBinId: BN$1, upperBinId: BN$1): BN$1[];
-declare function getBinArrayKeysCoverage(lowerBinId: BN$1, upperBinId: BN$1, lbPair: PublicKey, programId: PublicKey): PublicKey[];
-declare function getBinArrayAccountMetasCoverage(lowerBinId: BN$1, upperBinId: BN$1, lbPair: PublicKey, programId: PublicKey): AccountMeta[];
+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$1;
-    upperBinId: BN$1;
+    lowerBinId: BN;
+    upperBinId: BN;
 } | null;
 declare function isPositionNoFee(position: PositionData): boolean;
 declare function isPositionNoReward(position: PositionData): boolean;
@@ -10166,13 +10113,13 @@ declare function chunkBinRange(minBinId: number, maxBinId: number): {
 declare function chunkPositionBinRange(position: LbPosition, minBinId: number, maxBinId: number): {
     minBinId: number;
     maxBinId: number;
-    amountX: BN$1;
-    amountY: BN$1;
-    feeXAmount: BN$1;
-    feeYAmount: BN$1;
-    rewardAmounts: BN$1[];
+    amountX: BN;
+    amountY: BN;
+    feeXAmount: BN;
+    feeYAmount: BN;
+    rewardAmounts: BN[];
 }[];
-declare function calculatePositionSize(binCount: BN$1): BN$1;
+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.
@@ -10181,7 +10128,7 @@ declare function calculatePositionSize(binCount: BN$1): BN$1;
  * @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$1): Promise<number>;
+declare function getPositionRentExemption(connection: Connection, binCount: BN): Promise<number>;
 /**
  * Calculate the minimum lamports required to expand a position to a given
  * width.
@@ -10197,7 +10144,7 @@ declare function getPositionRentExemption(connection: Connection, binCount: BN$1
  * @returns The minimum lamports required to expand the position to the given
  * width.
  */
-declare function getPositionExpandRentExemption(currentMinBinId: BN$1, currentMaxBinId: BN$1, connection: Connection, binCountToExpand: BN$1): Promise<number>;
+declare function getPositionExpandRentExemption(currentMinBinId: BN, currentMaxBinId: BN, connection: Connection, binCountToExpand: BN): Promise<number>;
 /**
  * Calculate the number of extended bins in a position.
  *
@@ -10206,7 +10153,7 @@ declare function getPositionExpandRentExemption(currentMinBinId: BN$1, currentMa
  * @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$1, maxBinId: BN$1): BN$1;
+declare function getExtendedPositionBinCount(minBinId: BN, maxBinId: BN): BN;
 /**
  * Decode the extended position data.
  *
@@ -10233,39 +10180,39 @@ declare function decodeExtendedPosition(base: PositionV2, program: Program<LbClm
  * @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, amountY: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, strategyType: StrategyType, mintX: Mint, mintY: Mint, clock: Clock): {
+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;
-    amountY: BN;
+    amountX: BN$1;
+    amountY: BN$1;
 }[];
-declare function autoFillYByStrategy(activeId: number, binStep: number, amountX: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, minBinId: number, maxBinId: number, strategyType: StrategyType): BN;
-declare function autoFillXByStrategy(activeId: number, binStep: number, amountY: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, minBinId: number, maxBinId: number, strategyType: StrategyType): BN;
+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, amountY: BN, distributions: {
+declare function toWeightDistribution(amountX: BN$1, amountY: BN$1, distributions: {
     binId: number;
-    xAmountBpsOfTotal: BN;
-    yAmountBpsOfTotal: BN;
+    xAmountBpsOfTotal: BN$1;
+    yAmountBpsOfTotal: BN$1;
 }[], binStep: number): {
     binId: number;
     weight: number;
 }[];
 declare function calculateSpotDistribution(activeBin: number, binIds: number[]): {
     binId: number;
-    xAmountBpsOfTotal: BN;
-    yAmountBpsOfTotal: BN;
+    xAmountBpsOfTotal: BN$1;
+    yAmountBpsOfTotal: BN$1;
 }[];
 declare function calculateBidAskDistribution(activeBin: number, binIds: number[]): {
     binId: number;
-    xAmountBpsOfTotal: BN;
-    yAmountBpsOfTotal: BN;
+    xAmountBpsOfTotal: BN$1;
+    yAmountBpsOfTotal: BN$1;
 }[];
 declare function calculateNormalDistribution(activeBin: number, binIds: number[]): {
     binId: number;
-    xAmountBpsOfTotal: BN;
-    yAmountBpsOfTotal: BN;
+    xAmountBpsOfTotal: BN$1;
+    yAmountBpsOfTotal: BN$1;
 }[];
 /**
  * Converts a weight distribution into token amounts for one side (either bid or ask).
@@ -10279,12 +10226,12 @@ declare function calculateNormalDistribution(activeBin: number, binIds: number[]
  * @param clock - Clock instance for the current epoch. Get from DLMM instance.
  * @returns An array of objects containing binId and amount for each bin.
  */
-declare function fromWeightDistributionToAmountOneSide(amount: BN, distributions: {
+declare function fromWeightDistributionToAmountOneSide(amount: BN$1, distributions: {
     binId: number;
     weight: number;
 }[], binStep: number, activeId: number, depositForY: boolean, mint: Mint, clock: Clock): {
     binId: number;
-    amount: BN;
+    amount: BN$1;
 }[];
 /**
  * Converts a weight distribution into token amounts for both bid and ask sides.
@@ -10301,13 +10248,13 @@ declare function fromWeightDistributionToAmountOneSide(amount: BN, distributions
  * @param clock - Clock instance for the current epoch. Get from DLMM instance.
  * @returns An array of objects containing binId, amountX, and amountY for each bin.
  */
-declare function fromWeightDistributionToAmount(amountX: BN, amountY: BN, distributions: {
+declare function fromWeightDistributionToAmount(amountX: BN$1, amountY: BN$1, distributions: {
     binId: number;
     weight: number;
-}[], binStep: number, activeId: number, amountXInActiveBin: BN, amountYInActiveBin: BN, mintX: Mint, mintY: Mint, clock: Clock): {
+}[], binStep: number, activeId: number, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, mintX: Mint, mintY: Mint, clock: Clock): {
     binId: number;
-    amountX: BN;
-    amountY: BN;
+    amountX: BN$1;
+    amountY: BN$1;
 }[];
 
 /**
@@ -10319,12 +10266,12 @@ declare function fromWeightDistributionToAmount(amountX: BN, amountY: BN, distri
  * @param clock clock of the program, for calculating transfer fee, get from DLMM instance
  * @returns array of {binId, amount} where amount is the amount of token Y in each bin
  */
-declare function toAmountBidSide(activeId: number, totalAmount: BN, distributions: {
+declare function toAmountBidSide(activeId: number, totalAmount: BN$1, distributions: {
     binId: number;
     weight: number;
 }[], mintY: Mint, clock: Clock): {
     binId: number;
-    amount: BN;
+    amount: BN$1;
 }[];
 /**
  * Distribute totalAmount to all ask side bins according to given distributions.
@@ -10335,12 +10282,12 @@ declare function toAmountBidSide(activeId: number, totalAmount: BN, distribution
  * @param clock clock of the program, for calculating transfer fee, get from DLMM instance
  * @returns array of {binId, amount} where amount is the amount of token X in each bin
  */
-declare function toAmountAskSide(activeId: number, binStep: number, totalAmount: BN, distributions: {
+declare function toAmountAskSide(activeId: number, binStep: number, totalAmount: BN$1, distributions: {
     binId: number;
     weight: number;
 }[], mintX: Mint, clock: Clock): {
     binId: number;
-    amount: BN;
+    amount: BN$1;
 }[];
 /**
  * Distributes the given amounts of tokens X and Y to both bid and ask side bins
@@ -10358,22 +10305,22 @@ declare function toAmountAskSide(activeId: number, binStep: number, totalAmount:
  * @param clock - Clock instance. Get from DLMM instance.
  * @returns An array of objects containing binId, amountX, and amountY for each bin.
  */
-declare function toAmountBothSide(activeId: number, binStep: number, amountX: BN, amountY: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, distributions: {
+declare function toAmountBothSide(activeId: number, binStep: number, amountX: BN$1, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, distributions: {
     binId: number;
     weight: number;
 }[], mintX: Mint, mintY: Mint, clock: Clock): {
     binId: number;
-    amountX: BN;
-    amountY: BN;
+    amountX: BN$1;
+    amountY: BN$1;
 }[];
-declare function autoFillYByWeight(activeId: number, binStep: number, amountX: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, distributions: {
+declare function autoFillYByWeight(activeId: number, binStep: number, amountX: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, distributions: {
     binId: number;
     weight: number;
-}[]): BN;
-declare function autoFillXByWeight(activeId: number, binStep: number, amountY: BN, amountXInActiveBin: BN, amountYInActiveBin: BN, distributions: {
+}[]): BN$1;
+declare function autoFillXByWeight(activeId: number, binStep: number, amountY: BN$1, amountXInActiveBin: BN$1, amountYInActiveBin: BN$1, distributions: {
     binId: number;
     weight: number;
-}[]): BN;
+}[]): BN$1;
 
 declare function chunks<T>(array: T[], size: number): T[][];
 declare function range<T>(min: number, max: number, mapfn: (i: number) => T): T[];
@@ -10397,7 +10344,7 @@ declare function chunkedFetchMultiplePoolAccount(program: ClmmProgram, pks: Publ
         volatilityReference: number;
         indexReference: number;
         padding: number[];
-        lastUpdateTimestamp: BN;
+        lastUpdateTimestamp: BN$1;
         padding1: number[];
     };
     bumpSeed: number[];
@@ -10415,30 +10362,30 @@ declare function chunkedFetchMultiplePoolAccount(program: ClmmProgram, pks: Publ
     reserveX: PublicKey;
     reserveY: PublicKey;
     protocolFee: {
-        amountX: BN;
-        amountY: BN;
+        amountX: BN$1;
+        amountY: BN$1;
     };
     padding1: number[];
     rewardInfos: {
         mint: PublicKey;
         vault: PublicKey;
         funder: PublicKey;
-        rewardDuration: BN;
-        rewardDurationEnd: BN;
-        rewardRate: BN;
-        lastUpdateTime: BN;
-        cumulativeSecondsWithEmptyLiquidityReward: BN;
+        rewardDuration: BN$1;
+        rewardDurationEnd: BN$1;
+        rewardRate: BN$1;
+        lastUpdateTime: BN$1;
+        cumulativeSecondsWithEmptyLiquidityReward: BN$1;
     }[];
     oracle: PublicKey;
-    binArrayBitmap: BN[];
-    lastUpdatedAt: BN;
+    binArrayBitmap: BN$1[];
+    lastUpdatedAt: BN$1;
     padding2: number[];
     preActivationSwapAddress: PublicKey;
     baseKey: PublicKey;
-    activationPoint: BN;
-    preActivationDuration: BN;
+    activationPoint: BN$1;
+    preActivationDuration: BN$1;
     padding3: number[];
-    padding4: BN;
+    padding4: BN$1;
     creator: PublicKey;
     tokenMintXProgramFlag: number;
     tokenMintYProgramFlag: number;
@@ -10447,10 +10394,10 @@ declare function chunkedFetchMultiplePoolAccount(program: ClmmProgram, pks: Publ
 }[]>;
 declare function chunkedFetchMultipleBinArrayBitmapExtensionAccount(program: ClmmProgram, pks: PublicKey[], chunkSize?: number): Promise<{
     lbPair: PublicKey;
-    positiveBinArrayBitmap: BN[][];
-    negativeBinArrayBitmap: BN[][];
+    positiveBinArrayBitmap: BN$1[][];
+    negativeBinArrayBitmap: BN$1[][];
 }[]>;
-declare function getOutAmount(bin: Bin, inAmount: BN, swapForY: boolean): BN;
+declare function getOutAmount(bin: Bin, inAmount: BN$1, swapForY: boolean): BN$1;
 declare function getTokenDecimals(conn: Connection, mint: PublicKey): Promise<number>;
 declare const getOrCreateATAInstruction: (connection: Connection, tokenMint: PublicKey, owner: PublicKey, programId?: PublicKey, payer?: PublicKey, allowOwnerOffCurve?: boolean) => Promise<GetOrCreateATAResponse>;
 declare function getTokenBalance(conn: Connection, tokenAccount: PublicKey): Promise<bigint>;
@@ -10518,7 +10465,7 @@ declare function getBinCount(minBinId: number, maxBinId: number): number;
  * @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, slippage: number): BN;
+declare function getSlippageMaxAmount(amount: BN$1, slippage: number): BN$1;
 /**
  * Calculates the minimum amount of tokens after applying slippage to the given amount.
  *
@@ -10526,7 +10473,7 @@ declare function getSlippageMaxAmount(amount: BN, slippage: number): BN;
  * @param slippage The percentage of slippage to apply.
  * @returns The minimum amount of tokens after applying slippage.
  */
-declare function getSlippageMinAmount(amount: BN, slippage: number): BN;
+declare function getSlippageMinAmount(amount: BN$1, slippage: number): BN$1;
 /**
  * Calculates the number of positions required to cover a range of bins.
  *
@@ -10550,11 +10497,11 @@ declare function getPositionCountByBinCount(binCount: number): number;
  * @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, maxDeltaId: BN, favorXInActiveId: boolean, params: LiquidityStrategyParameters): {
-    x0: BN;
-    y0: BN;
-    deltaX: BN;
-    deltaY: BN;
+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, isParallel: boolean, skipSolWrappingOperation?: boolean): Promise<TransactionInstruction[][]>;
 
@@ -10592,7 +10539,7 @@ declare class DLMM {
      * @param opt Optional parameters.
      * @returns The public key of the LB pair if it exists, or null.
      */
-    static getPairPubkeyIfExists(connection: Connection, tokenX: PublicKey, tokenY: PublicKey, binStep: BN, baseFactor: BN, baseFeePowerFactor: BN, opt?: Opt): Promise<PublicKey | null>;
+    static getPairPubkeyIfExists(connection: Connection, tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, baseFactor: BN$1, baseFeePowerFactor: BN$1, opt?: Opt): Promise<PublicKey | null>;
     static getCustomizablePermissionlessLbPairIfExists(connection: Connection, tokenX: PublicKey, tokenY: PublicKey, opt?: Opt): Promise<PublicKey | null>;
     /**
      * The `create` function is a static method that creates a new instance of the `DLMM` class
@@ -10651,7 +10598,7 @@ declare class DLMM {
             index: number;
             baseFeePowerFactor: number;
             functionType: number;
-            padding1: BN[];
+            padding1: BN$1[];
         }>[];
     }>;
     /**
@@ -10692,7 +10639,7 @@ declare class DLMM {
      * @param opt An options object.
      * @returns A transaction that creates the pair.
      */
-    static createCustomizablePermissionlessLbPair2(connection: Connection, binStep: BN, tokenX: PublicKey, tokenY: PublicKey, activeId: BN, feeBps: BN, activationType: ActivationType, hasAlphaVault: boolean, creatorKey: PublicKey, functionType: FunctionType, activationPoint?: BN, creatorPoolOnOffControl?: boolean, opt?: Opt): Promise<Transaction>;
+    static createCustomizablePermissionlessLbPair2(connection: Connection, binStep: BN$1, tokenX: PublicKey, tokenY: PublicKey, activeId: BN$1, feeBps: BN$1, activationType: ActivationType, hasAlphaVault: boolean, creatorKey: PublicKey, activationPoint?: BN$1, creatorPoolOnOffControl?: boolean, opt?: Opt): Promise<Transaction>;
     /**
      * Create a new customizable permissionless pair. Support only token program.
      * @param connection A connection to the Solana cluster.
@@ -10708,7 +10655,7 @@ declare class DLMM {
      * @param opt An options object.
      * @returns A transaction that creates the pair.
      */
-    static createCustomizablePermissionlessLbPair(connection: Connection, binStep: BN, tokenX: PublicKey, tokenY: PublicKey, activeId: BN, feeBps: BN, activationType: ActivationType, hasAlphaVault: boolean, creatorKey: PublicKey, functionType: FunctionType, activationPoint?: BN, creatorPoolOnOffControl?: boolean, opt?: Opt): Promise<Transaction>;
+    static createCustomizablePermissionlessLbPair(connection: Connection, binStep: BN$1, tokenX: PublicKey, tokenY: PublicKey, activeId: BN$1, feeBps: BN$1, activationType: ActivationType, hasAlphaVault: boolean, creatorKey: PublicKey, activationPoint?: BN$1, creatorPoolOnOffControl?: boolean, opt?: Opt): Promise<Transaction>;
     /**
      * Create a new liquidity pair. Support only token program.
      * @param connection A connection to the Solana cluster.
@@ -10723,7 +10670,7 @@ declare class DLMM {
      * @returns A transaction that creates the pair.
      * @throws If the pair already exists.
      */
-    static createLbPair(connection: Connection, funder: PublicKey, tokenX: PublicKey, tokenY: PublicKey, binStep: BN, baseFactor: BN, presetParameter: PublicKey, activeId: BN, opt?: Opt): Promise<Transaction>;
+    static createLbPair(connection: Connection, funder: PublicKey, tokenX: PublicKey, tokenY: PublicKey, binStep: BN$1, baseFactor: BN$1, presetParameter: PublicKey, activeId: BN$1, opt?: Opt): Promise<Transaction>;
     /**
      * Create a new liquidity pair. Support both token and token2022 program.
      * @param connection A connection to the Solana cluster.
@@ -10736,7 +10683,7 @@ declare class DLMM {
      * @returns A transaction that creates the pair.
      * @throws If the pair already exists.
      */
-    static createLbPair2(connection: Connection, funder: PublicKey, tokenX: PublicKey, tokenY: PublicKey, presetParameter: PublicKey, activeId: BN, opt?: Opt): Promise<Transaction>;
+    static createLbPair2(connection: Connection, funder: PublicKey, tokenX: PublicKey, tokenY: PublicKey, presetParameter: PublicKey, activeId: BN$1, opt?: Opt): Promise<Transaction>;
     /**
      * The function `refetchStates` retrieves and updates various states and data related to bin arrays
      * and lb pairs.
@@ -10897,7 +10844,7 @@ declare class DLMM {
      *   - positionExtendCost: The estimated rent cost in lamports for extending the position.
      *   - binArrayCost: The estimated cost for creating necessary bin arrays.
      */
-    quoteExtendPosition(currentMinBinId: BN, currentMaxBinId: BN, binCountToExpand: BN): Promise<{
+    quoteExtendPosition(currentMinBinId: BN$1, currentMaxBinId: BN$1, binCountToExpand: BN$1): Promise<{
         positionExtendCost: Decimal;
         binArrayCost: Decimal;
     }>;
@@ -10945,7 +10892,7 @@ declare class DLMM {
      * @param slippagePercentage The slippage percentage for adding liquidity.
      * @returns An object with two properties: `initPositionIxs` and `addLiquidityIxs`.
      */
-    initializeMultiplePositionAndAddLiquidityByStrategy2(positionKeypairGenerator: (count: number) => Promise<Keypair[]>, totalXAmount: BN, totalYAmount: BN, strategy: StrategyParameters, owner: PublicKey, payer: PublicKey, slippagePercentage: number, altAddress?: PublicKey): Promise<InitializeMultiplePositionAndAddLiquidityByStrategyResponse2>;
+    initializeMultiplePositionAndAddLiquidityByStrategy2(positionKeypairGenerator: (count: number) => Promise<Keypair[]>, totalXAmount: BN$1, totalYAmount: BN$1, strategy: StrategyParameters, owner: PublicKey, payer: PublicKey, slippagePercentage: number, altAddress?: PublicKey): Promise<InitializeMultiplePositionAndAddLiquidityByStrategyResponse2>;
     /**
      * Creates multiple positions and adds liquidity by strategy without chainsaw issues.
      * @param positionKeypairGenerator A function that generates a specified number of keypairs.
@@ -10957,7 +10904,7 @@ declare class DLMM {
      * @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, totalYAmount: BN, strategy: StrategyParameters, owner: PublicKey, payer: PublicKey, slippagePercentage: number): Promise<InitializeMultiplePositionAndAddLiquidityByStrategyResponse>;
+    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.
@@ -11045,7 +10992,7 @@ declare class DLMM {
         position: PublicKey;
         fromBinId: number;
         toBinId: number;
-        bps: BN;
+        bps: BN$1;
         shouldClaimAndClose?: boolean;
         skipUnwrapSOL?: boolean;
     }): Promise<Transaction[]>;
@@ -11084,7 +11031,7 @@ declare class DLMM {
      * @throws {DlmmSdkError}
      *
      */
-    swapQuoteExactOut(outAmount: BN, swapForY: boolean, allowedSlippage: BN, binArrays: BinArrayAccount[], maxExtraBinArrays?: number): SwapQuoteExactOut;
+    swapQuoteExactOut(outAmount: BN$1, swapForY: boolean, allowedSlippage: BN$1, binArrays: BinArrayAccount[], maxExtraBinArrays?: number): SwapQuoteExactOut;
     /**
      * The `swapQuote` function returns a quote for a swap
      * @param
@@ -11104,7 +11051,7 @@ declare class DLMM {
      *    - `binArraysPubkey`: Array of bin arrays involved in the swap
      * @throws {DlmmSdkError}
      */
-    swapQuote(inAmount: BN, swapForY: boolean, allowedSlippage: BN, binArrays: BinArrayAccount[], isPartialFill?: boolean, maxExtraBinArrays?: number): SwapQuote;
+    swapQuote(inAmount: BN$1, swapForY: boolean, allowedSlippage: BN$1, binArrays: BinArrayAccount[], isPartialFill?: boolean, maxExtraBinArrays?: number): SwapQuote;
     swapExactOut({ inToken, outToken, outAmount, maxInAmount, lbPair, user, binArraysPubkey, }: SwapExactOutParams): Promise<Transaction>;
     /**
      * Returns a transaction to be signed and sent by user performing swap.
@@ -11155,7 +11102,7 @@ declare class DLMM {
         owner: PublicKey;
         positions: LbPosition[];
     }): Promise<Transaction[]>;
-    setActivationPoint(activationPoint: BN): Promise<Transaction>;
+    setActivationPoint(activationPoint: BN$1): Promise<Transaction>;
     setPairStatus(enabled: boolean): Promise<Transaction>;
     /**
      * The function `claimSwapFee` is used to claim swap fees for a specific position owned by a specific owner.
@@ -11207,7 +11154,7 @@ declare class DLMM {
      *    - `shouldSeedPositionOwner` (optional): Whether to send 1 lamport amount of token X to the position owner to prove ownership.
      * @returns {Promise<SeedLiquidityResponse>}
      */
-    seedLiquidity(owner: PublicKey, seedAmount: BN, curvature: number, minPrice: number, maxPrice: number, base: PublicKey, payer: PublicKey, feeOwner: PublicKey, operator: PublicKey, lockReleasePoint: BN, shouldSeedPositionOwner?: boolean): Promise<SeedLiquidityResponse>;
+    seedLiquidity(owner: PublicKey, seedAmount: BN$1, curvature: number, minPrice: number, maxPrice: number, base: PublicKey, payer: PublicKey, feeOwner: PublicKey, operator: PublicKey, lockReleasePoint: BN$1, shouldSeedPositionOwner?: boolean): Promise<SeedLiquidityResponse>;
     /**
      * The `seedLiquiditySingleBin` function seed liquidity into a single bin.
      * @param
@@ -11225,7 +11172,7 @@ declare class DLMM {
      * The returned instructions need to be executed sequentially if it was separated into multiple transactions.
      * @returns {Promise<SeedLiquiditySingleBinResponse>}
      */
-    seedLiquiditySingleBin(payer: PublicKey, base: PublicKey, seedAmount: BN, price: number, roundingUp: boolean, positionOwner: PublicKey, feeOwner: PublicKey, operator: PublicKey, lockReleasePoint: BN, shouldSeedPositionOwner?: boolean): Promise<SeedLiquiditySingleBinResponse>;
+    seedLiquiditySingleBin(payer: PublicKey, base: PublicKey, seedAmount: BN$1, price: number, roundingUp: boolean, positionOwner: PublicKey, feeOwner: PublicKey, operator: PublicKey, lockReleasePoint: BN$1, shouldSeedPositionOwner?: boolean): Promise<SeedLiquiditySingleBinResponse>;
     /**
      * Initializes bin arrays for the given bin array indexes if it wasn't initialized.
      *
@@ -11233,7 +11180,7 @@ declare class DLMM {
      * @param {PublicKey} funder - The public key of the funder.
      * @return {Promise<TransactionInstruction[]>} An array of transaction instructions to initialize the bin arrays.
      */
-    initializeBinArrays(binArrayIndexes: BN[], funder: PublicKey): Promise<TransactionInstruction[]>;
+    initializeBinArrays(binArrayIndexes: BN$1[], funder: PublicKey): Promise<TransactionInstruction[]>;
     /**
      *
      * @param
@@ -11248,14 +11195,14 @@ declare class DLMM {
      * @returns
      */
     initializePositionByOperator({ lowerBinId, positionWidth, owner, feeOwner, base, operator, payer, lockReleasePoint, }: {
-        lowerBinId: BN;
-        positionWidth: BN;
+        lowerBinId: BN$1;
+        positionWidth: BN$1;
         owner: PublicKey;
         feeOwner: PublicKey;
         operator: PublicKey;
         payer: PublicKey;
         base: PublicKey;
-        lockReleasePoint: BN;
+        lockReleasePoint: BN$1;
     }): Promise<Transaction>;
     /**
      * The `claimAllRewards` function to claim swap fees and LM rewards for multiple positions owned by a specific owner.
@@ -11293,7 +11240,7 @@ declare class DLMM {
      * @param allowParallelExecution If true, the instructions will be grouped to allow parallel execution. Otherwise, the instructions will be executed sequentially.
      * @returns An array of transactions if allowParallelExecution is true. Otherwise, an empty array.
      */
-    decreasePositionLength(position: PublicKey, side: ResizeSide, length: BN, allowParallelExecution?: boolean): Promise<Transaction[]>;
+    decreasePositionLength(position: PublicKey, side: ResizeSide, length: BN$1, allowParallelExecution?: boolean): Promise<Transaction[]>;
     /**
      * Expand the position bin range to the left or right (lower or upper).
      *
@@ -11305,8 +11252,8 @@ declare class DLMM {
      * @param allowParallelExecution Whether to allow parallel execution of the transaction.
      * @returns The transaction to execute this instruction.
      */
-    increasePositionLength(position: PublicKey, side: ResizeSide, length: BN, funder: PublicKey, allowParallelExecution?: boolean): Promise<Transaction[]>;
-    simulateRebalancePositionWithBalancedStrategy(positionAddress: PublicKey, positionData: PositionData, strategy: StrategyType, topUpAmountX: BN, topUpAmountY: BN, xWithdrawBps: BN, yWithdrawBps: BN): Promise<RebalancePositionResponse & RebalancePositionBinArrayRentalCostQuote>;
+    increasePositionLength(position: PublicKey, side: ResizeSide, length: BN$1, funder: PublicKey, allowParallelExecution?: boolean): Promise<Transaction[]>;
+    simulateRebalancePositionWithBalancedStrategy(positionAddress: PublicKey, positionData: PositionData, strategy: StrategyType, topUpAmountX: BN$1, topUpAmountY: BN$1, xWithdrawBps: BN$1, yWithdrawBps: BN$1): Promise<RebalancePositionResponse & RebalancePositionBinArrayRentalCostQuote>;
     private simulateRebalancePositionWithStrategy;
     private quoteBinArrayAccountsRentalCost;
     /**
@@ -11329,7 +11276,7 @@ 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, rentPayer?: PublicKey, slippage?: number): Promise<{
+    rebalancePosition(rebalancePositionResponse: RebalancePositionResponse, maxActiveBinSlippage: BN$1, rentPayer?: PublicKey, slippage?: number): Promise<{
         initBinArrayInstructions: TransactionInstruction[];
         rebalancePositionInstruction: TransactionInstruction[];
     }>;
@@ -22531,9 +22478,62 @@ declare class DlmmSdkError extends Error {
     constructor(name: ErrorName, message: string);
 }
 
-declare const presetParameter2BinStepFilter: (binStep: BN$1) => GetProgramAccountsFilter;
-declare const presetParameter2BaseFactorFilter: (baseFactor: BN$1) => GetProgramAccountsFilter;
-declare const presetParameter2BaseFeePowerFactor: (baseFeePowerFactor: BN$1) => GetProgramAccountsFilter;
+declare const LBCLMM_PROGRAM_IDS: {
+    devnet: string;
+    localhost: string;
+    "mainnet-beta": string;
+};
+declare const ALT_ADDRESS: {
+    "mainnet-beta": string;
+    devnet: string;
+};
+declare const ADMIN: {
+    devnet: string;
+    localhost: string;
+};
+declare enum Network {
+    MAINNET = "mainnet-beta",
+    TESTNET = "testnet",
+    DEVNET = "devnet",
+    LOCAL = "localhost"
+}
+declare const BASIS_POINT_MAX = 10000;
+declare const SCALE_OFFSET = 64;
+declare const SCALE: BN$1;
+declare const FEE_PRECISION: BN$1;
+declare const MAX_FEE_RATE: BN$1;
+declare const BIN_ARRAY_FEE = 0.07143744;
+declare const POSITION_FEE = 0.05740608;
+declare const TOKEN_ACCOUNT_FEE = 0.00203928;
+declare const POOL_FEE = 0.00718272;
+declare const BIN_ARRAY_BITMAP_FEE = 0.01180416;
+declare const BIN_ARRAY_FEE_BN: BN$1;
+declare const POSITION_FEE_BN: BN$1;
+declare const TOKEN_ACCOUNT_FEE_BN: BN$1;
+declare const POOL_FEE_BN: BN$1;
+declare const BIN_ARRAY_BITMAP_FEE_BN: BN$1;
+declare const MAX_BIN_ARRAY_SIZE: BN$1;
+declare const DEFAULT_BIN_PER_POSITION: BN$1;
+declare const BIN_ARRAY_BITMAP_SIZE: BN$1;
+declare const EXTENSION_BINARRAY_BITMAP_SIZE: BN$1;
+declare const POSITION_MAX_LENGTH: BN$1;
+declare const MAX_RESIZE_LENGTH: BN$1;
+declare const SIMULATION_USER: PublicKey;
+declare const PRECISION = 18446744073709552000;
+declare const MAX_CLAIM_ALL_ALLOWED = 2;
+declare const MAX_BIN_LENGTH_ALLOWED_IN_ONE_TX = 26;
+declare const MAX_ACTIVE_BIN_SLIPPAGE = 3;
+declare const ILM_BASE: PublicKey;
+declare const MAX_EXTRA_BIN_ARRAYS = 3;
+declare const U64_MAX: BN$1;
+declare const MAX_BINS_PER_POSITION: BN$1;
+declare enum FunctionType {
+    LiquidityMining = 0
+}
+
+declare const presetParameter2BinStepFilter: (binStep: BN) => GetProgramAccountsFilter;
+declare const presetParameter2BaseFactorFilter: (baseFactor: BN) => GetProgramAccountsFilter;
+declare const presetParameter2BaseFeePowerFactor: (baseFeePowerFactor: BN) => GetProgramAccountsFilter;
 declare const binArrayLbPairFilter: (lbPair: PublicKey) => GetProgramAccountsFilter;
 declare const positionOwnerFilter: (owner: PublicKey) => GetProgramAccountsFilter;
 declare const positionLbPairFilter: (lbPair: PublicKey) => GetProgramAccountsFilter;