SDK Functions

enum StrategyType {
  Spot,   // Uniform distribution across all bins
  Curve,  // Bell-curve distribution concentrated near the active bin
  BidAsk, // V-shaped distribution with more weight at price extremes
}

interface StrategyParameters {
  maxBinId: number;        // Upper bound of the target bin range
  minBinId: number;        // Lower bound of the target bin range
  strategyType: StrategyType; // Distribution strategy
  singleSidedX?: boolean;  // If true, deposit only token X (ask side only)
}

enum ActivationType {
  Slot,      // Activation based on slot number
  Timestamp, // Activation based on Unix timestamp
}

async create(
    connection: Connection, 
    dlmm: PublicKey, 
    opt?: {
        cluster?: Cluster | "localhost"; 
        programId?: PublicKey; 
    }
): Promise<DLMM>

connection: Connection         // Solana connection instance
dlmm: PublicKey                // The DLMM pool address
opt?: {                        // Optional parameters
  cluster?: Cluster | "localhost"; // The Solana cluster (mainnet, devnet, etc.)
  programId?: PublicKey; // Custom program ID if different from default
}

// Creating a DLMM pool
// You can get your desired pool address from the API https://dlmm.datapi.meteora.ag/pair/all
const USDC_USDT_POOL = new PublicKey('ARwi1S4DaiTG5DX7S4M4ZsrXqpMD1MrTmbu9ue2tpmEq')
const dlmmPool = await DLMM.create(connection, USDC_USDT_POOL);

async createMultiple(
    connection: Connection, 
    dlmmList: Array<PublicKey>,
    opt?: {
        cluster?: Cluster | "localhost"; 
        programId?: PublicKey; 
    }
): Promise<DLMM[]>

connection: Connection         // Solana connection instance
dlmmList: Array<PublicKey>     // The array of DLMM pool addresses
opt?: {                        // Optional parameters
  cluster?: Cluster | "localhost"; // The Solana cluster (mainnet, devnet, etc.)
  programId?: PublicKey; // Custom program ID if different from default
}

// Creating a DLMM pool
// You can get your desired pool address from the API https://dlmm.datapi.meteora.ag/pair/all
const USDC_USDT_POOL = new PublicKey('ARwi1S4DaiTG5DX7S4M4ZsrXqpMD1MrTmbu9ue2tpmEq')
const dlmmPool = await DLMM.createMultiple(connection, [USDC_USDT_POOL, ...]);

static async createCustomizablePermissionlessLbPair(
    connection: Connection,
    binStep: BN,
    tokenX: PublicKey,
    tokenY: PublicKey,
    activeId: BN,
    feeBps: BN,
    activationType: ActivationType,
    hasAlphaVault: boolean,
    creatorKey: PublicKey,
    activationPoint?: BN,
    creatorPoolOnOffControl?: boolean,
    opt?: {
      cluster?: Cluster | "localhost";
      programId?: PublicKey;
    };
): Promise<Transaction>

connection: Connection         // Solana connection instance
binStep: BN                    // Bin step of the pair
tokenX: PublicKey              // Token X mint address
tokenY: PublicKey              // Token Y mint address
activeId: BN                   // Active bin ID
feeBps: BN                     // Fee in basis points
activationType: ActivationType // Activation type
hasAlphaVault: boolean         // Whether the pair has an alpha vault
creatorKey: PublicKey          // Creator key
activationPoint?: BN           // Optional activation point
creatorPoolOnOffControl?: boolean // Optional creator pool on/off control
opt?: Opt                      // Optional parameters

const WEN = new PublicKey('WENWENvqqNya429ubCdR81ZmD69brwQaaBYY6p3LCpk')
const USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

const binId = 8388608
const feeBps = new BN(100)
const activationPoint = new BN(1720000000)
const owner = new Keypair()

// Create a customizable permissionless LB pair
const transaction = await DLMM.createCustomizablePermissionlessLbPair(
  connection,
  new BN(binStep),
  WEN,
  USDC,
  new BN(binId.toString()),
  feeBps,
  ActivationType.Slot,
  false, // No alpha vault. 
  owner.publicKey,
  activationPoint,
  false,
  {
    cluster: "localhost",
  }
);

static async createCustomizablePermissionlessLbPair2(
    connection: Connection,
    binStep: BN,
    tokenX: PublicKey,
    tokenY: PublicKey,
    activeId: BN,
    feeBps: BN,
    activationType: ActivationType,
    hasAlphaVault: boolean,
    creatorKey: PublicKey,
    activationPoint?: BN,
    creatorPoolOnOffControl?: boolean,
    opt?: Opt
): Promise<Transaction>

connection: Connection         // Solana connection instance
binStep: BN                   // The bin step for the pair
tokenX: PublicKey             // The mint of the first token
tokenY: PublicKey             // The mint of the second token
activeId: BN                  // The ID of the initial active bin (starting price)
feeBps: BN                    // The fee rate for swaps in basis points
activationType: ActivationType // The type of activation for the pair
hasAlphaVault: boolean        // Whether the pair has an alpha vault
creatorKey: PublicKey         // The public key of the creator
activationPoint?: BN          // Optional timestamp for activation
creatorPoolOnOffControl?: boolean // Optional creator control flag
opt?: Opt                     // Optional cluster and program ID

const WEN = new PublicKey('WENWENvqqNya429ubCdR81ZmD69brwQaaBYY6p3LCpk')
const USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

const binId = 8388608
const feeBps = new BN(100)
const activationPoint = new BN(1720000000)
const owner = new Keypair()

const transaction = await DLMM.createCustomizablePermissionlessLbPair2(
  connection,
  new BN(25), // 0.25% bin step
  WEN,
  USDC,
  new BN(binId.toString()), // active bin ID representing starting price
  new BN(feeBps.toString()), // 1% fee
  ActivationType.Timestamp,
  false, // no alpha vault
  owner.publicKey,
  activationPoint,
  false,
  {
    cluster: "localhost",
  }
);

static async createLbPair(
    connection: Connection,
    funder: PublicKey,
    tokenX: PublicKey,
    tokenY: PublicKey,
    binStep: BN,
    baseFactor: BN,
    presetParameter: PublicKey,
    activeId: BN,
    opt?: Opt
): Promise<Transaction>

connection: Connection        // Solana connection instance
funder: PublicKey             // The public key of the funder
tokenX: PublicKey             // The mint of the first token
tokenY: PublicKey             // The mint of the second token
binStep: BN                   // The bin step for the pair
baseFactor: BN                // The base factor for the pair
presetParameter: PublicKey    // The public key of the preset parameter account
activeId: BN                  // The ID of the initial active bin
opt?: Opt                     // Optional parameters

const WEN = new PublicKey('WENWENvqqNya429ubCdR81ZmD69brwQaaBYY6p3LCpk')
const USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

const activeBinId = 8388608
const binStep = new BN(25)
const baseFactor = new BN(10000)

const presetParamPda = derivePresetParameter2(
  binStep,
  baseFactor,
  programId
);

const activationPoint = new BN(1720000000)
const owner = new Keypair()

const transaction = await DLMM.createLbPair(
  connection,
  owner.publicKey,
  WEN,
  USDC,
  binStep,
  baseFactor, // base factor
  presetParamPda,
  activeBinId // active bin ID
);

static async createLbPair2(
    connection: Connection,
    funder: PublicKey,
    tokenX: PublicKey,
    tokenY: PublicKey,
    presetParameter: PublicKey,
    activeId: BN,
    opt?: Opt
): Promise<Transaction>

connection: Connection        // Solana connection instance
funder: PublicKey             // The public key of the funder
tokenX: PublicKey             // The mint of the first token
tokenY: PublicKey             // The mint of the second token
presetParameter: PublicKey    // The public key of the preset parameter account
activeId: BN                  // The ID of the initial active bin
opt?: Opt                     // Optional parameters

const WEN = new PublicKey('WENWENvqqNya429ubCdR81ZmD69brwQaaBYY6p3LCpk')
const USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

const activeBinId = 8388608
const binStep = new BN(25)
const baseFactor = new BN(10000)
const programId = LBCLMM_PROGRAM_IDS["mainnet-beta"]

const presetParamPda = derivePresetParameter2(
  binStep,
  baseFactor,
  programId
);


const transaction = await DLMM.createLbPair2(
  connection,
  owner.publicKey,
  WEN,
  USDC,
  presetParamPda,
  activeBinId // active bin ID
);

async initializePositionAndAddLiquidityByStrategy({
    positionPubKey,
    totalXAmount,
    totalYAmount,
    strategy,
    user,
    slippage,
}: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction>

positionPubKey: PublicKey     // The public key of the position account (usually new Keypair())
totalXAmount: BN              // Total amount of token X to add
totalYAmount: BN              // Total amount of token Y to add
strategy: StrategyParameters  // Strategy parameters (can use calculateStrategyParameter)
user: PublicKey               // The public key of the user account
slippage?: number             // Optional slippage percentage

const positionKeypair = new Keypair();

const btcInAmount = new BN(1).mul(new BN(10 ** btcDecimal));
const usdcInAmount = new BN(24000).mul(new BN(10 ** usdcDecimal));

const strategy = {
  strategyType: StrategyType.SpotBalanced,
  minBinId: 8388600,
  maxBinId: 8388620,
};

const transaction = await dlmmPool.initializePositionAndAddLiquidityByStrategy({
  positionPubKey: positionKeypair.publicKey,
  totalXAmount: btcInAmount,
  totalYAmount: usdcInAmount,
  strategy,
  user: userPublicKey,
  slippage: 1 // 1% slippage
});

async addLiquidityByStrategy({
    positionPubKey,
    totalXAmount,
    totalYAmount,
    strategy,
    user,
    slippage,
}: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction>

positionPubKey: PublicKey     // The public key of the existing position
totalXAmount: BN              // Total amount of token X to add
totalYAmount: BN              // Total amount of token Y to add
strategy: StrategyParameters  // Strategy parameters
user: PublicKey               // The public key of the user account
slippage?: number             // Optional slippage percentage

const btcInAmount = new BN(1).mul(new BN(10 ** btcDecimal));
const usdcInAmount = new BN(24000).mul(new BN(10 ** usdcDecimal));

const transaction = await dlmmPool.addLiquidityByStrategy({
  positionPubKey: position.publicKey,
  totalXAmount: btcInAmount,
  totalYAmount: usdcInAmount,
  strategy: {
    minBinId: 8388600,
    maxBinId: 8388620,
    strategyType: StrategyType.SpotBalanced,
  },
  user: userPublicKey,
  slippage: 1
});

async addLiquidityByStrategyChunkable({
    positionPubKey,
    totalXAmount,
    totalYAmount,
    strategy,
    user,
    slippage,
}: TInitializePositionAndAddLiquidityParamsByStrategy): Promise<Transaction[]>

positionPubKey: PublicKey     // The public key of the existing position
totalXAmount: BN              // Total amount of token X to add
totalYAmount: BN              // Total amount of token Y to add
strategy: StrategyParameters  // Strategy parameters defining the bin range and type
user: PublicKey               // The public key of the user
slippage?: number             // Optional slippage percentage

const transactions = await dlmmPool.addLiquidityByStrategyChunkable({
  positionPubKey: position.publicKey,
  totalXAmount: new BN(1_000_000),
  totalYAmount: new BN(24_000_000),
  strategy: {
    minBinId: 8388600,
    maxBinId: 8388670,
    strategyType: StrategyType.SpotBalanced,
  },
  user: userPublicKey,
  slippage: 1,
});

for (const tx of transactions) {
  await sendAndConfirmTransaction(connection, tx, [userKeypair]);
}

async initializeMultiplePositionAndAddLiquidityByStrategy(
    positionKeypairGenerator: (count: number) => Promise<Keypair[]>,
    totalXAmount: BN,
    totalYAmount: BN,
    strategy: StrategyParameters,
    owner: PublicKey,
    payer: PublicKey,
    slippagePercentage: number
): Promise<InitializeMultiplePositionAndAddLiquidityByStrategyResponse>

positionKeypairGenerator: (count: number) => Promise<Keypair[]>
                                // Async function that generates the required keypairs
totalXAmount: BN                // Total amount of token X to add
totalYAmount: BN                // Total amount of token Y to add
strategy: StrategyParameters    // Strategy parameters defining the bin range and type
owner: PublicKey                // Owner of the positions
payer: PublicKey                // Payer for rent and transaction fees
slippagePercentage: number      // Slippage tolerance as a percentage

{
  instructionsByPositions: {
    positionKeypair: Keypair;
    initializePositionIx: TransactionInstruction;
    initializeAtaIxs: TransactionInstruction[];
    addLiquidityIxs: TransactionInstruction[][];
  }[];
}

const response = await dlmmPool.initializeMultiplePositionAndAddLiquidityByStrategy(
  async (count) => Array.from({ length: count }, () => new Keypair()),
  new BN(1_000_000),
  new BN(24_000_000),
  {
    minBinId: 8388550,
    maxBinId: 8388700,
    strategyType: StrategyType.SpotBalanced,
  },
  userPublicKey,
  userPublicKey,
  1 // 1% slippage
);

for (const { positionKeypair, initializePositionIx, initializeAtaIxs, addLiquidityIxs } of response.instructionsByPositions) {
  // Build and send transactions for each position
}

async removeLiquidity({
    user,
    position,
    fromBinId,
    toBinId,
    bps,
    shouldClaimAndClose = false,
    skipUnwrapSOL = false,
}: {
    user: PublicKey;
    position: PublicKey;
    fromBinId: number;
    toBinId: number;
    bps: BN;
    shouldClaimAndClose?: boolean;
    skipUnwrapSOL?: boolean;
}): Promise<Transaction[]>

user: PublicKey               // The public key of the user account
position: PublicKey           // The public key of the position account
fromBinId: number             // Starting bin ID to remove liquidity from
toBinId: number               // Ending bin ID to remove liquidity from
bps: BN                       // Percentage of liquidity to remove (in basis points)
shouldClaimAndClose?: boolean // Whether to claim rewards and close position (default: false)
skipUnwrapSOL?: boolean       // Whether to skip unwrapping wSOL to SOL (default: false)

// Remove 50% of liquidity from position
const transaction = await dlmmPool.removeLiquidity({
  user: userPublicKey,
  position: positionPublicKey,
  fromBinId: 8388600,
  toBinId: 8388620,
  bps: new BN(5000), // 50% in basis points
  shouldClaimAndClose: false
});

swapQuote(
    inAmount: BN,
    swapForY: boolean,
    allowedSlippage: BN,
    binArrays: BinArrayAccount[],
    isPartialFill?: boolean,
    maxExtraBinArrays: number = 0
): SwapQuote

inAmount: BN                  // Amount of lamports to swap in
swapForY: boolean             // True to swap X to Y, false for Y to X
allowedSlippage: BN           // Allowed slippage in basis points
binArrays: BinArrayAccount[]  // Bin arrays for the swap quote
isPartialFill?: boolean       // Whether partial fill is allowed
maxExtraBinArrays?: number    // Maximum extra bin arrays to return

const binArrays = await dlmmPool.getBinArrayForSwap(true, 5);
const swapQuote = dlmmPool.swapQuote(
  new BN(1000000), // 1 token input
  true, // swap X for Y
  new BN(100), // 1% slippage
  binArrays,
  false, // no partial fill
  2 // max extra bin arrays
);

swapQuoteExactOut(
    outAmount: BN,
    swapForY: boolean,
    allowedSlippage: BN,
    binArrays: BinArrayAccount[],
    maxExtraBinArrays: number = 0
): SwapQuoteExactOut

outAmount: BN                 // Amount of lamports to swap out
swapForY: boolean             // True to swap X to Y, false for Y to X
allowedSlippage: BN           // Allowed slippage in basis points
binArrays: BinArrayAccount[]  // Bin arrays for the swap quote
maxExtraBinArrays?: number    // Maximum extra bin arrays to return

const binArrays = await dlmmPool.getBinArrayForSwap(true, 5);
const swapQuote = dlmmPool.swapQuoteExactOut(
  new BN(1000000), // 1 token output
  true, // swap X for Y
  new BN(100), // 1% slippage
  binArrays,
  2 // max extra bin arrays
);

async swapExactOut({
    inToken,
    outToken,
    outAmount,
    maxInAmount,
    lbPair,
    user,
    binArraysPubkey,
}: SwapExactOutParams): Promise<Transaction>

inToken: PublicKey            // The public key of input token mint
outToken: PublicKey           // The public key of output token mint
outAmount: BN                 // Exact amount of output token to receive
maxInAmount: BN               // Maximum amount of input token to spend
lbPair: PublicKey             // The public key of the liquidity pool
user: PublicKey               // The public key of the user account
binArraysPubkey: PublicKey[]  // Array of bin arrays involved in swap

const swapTx = await dlmmPool.swapExactOut({
  inToken: tokenXMint,
  outToken: tokenYMint,
  outAmount: new BN(1000000), 
  maxInAmount: new BN(1100000), 
  lbPair: dlmmPool.pubkey,
  user: userPublicKey,
  binArraysPubkey: swapQuote.binArraysPubkey
});

async swapWithPriceImpact({
    inToken,
    outToken,
    inAmount,
    lbPair,
    user,
    priceImpact,
    binArraysPubkey,
}: SwapWithPriceImpactParams): Promise<Transaction>

inToken: PublicKey            // The public key of input token mint
outToken: PublicKey           // The public key of output token mint
inAmount: BN                  // Amount of input token to swap
lbPair: PublicKey             // The public key of the liquidity pool
user: PublicKey               // The public key of the user account
priceImpact: BN               // Accepted price impact in basis points
binArraysPubkey: PublicKey[]  // Array of bin arrays involved in swap

const swapTx = await dlmmPool.swapWithPriceImpact({
  inToken: tokenXMint,
  outToken: tokenYMint,
  inAmount: new BN(1000000),
  lbPair: dlmmPool.pubkey,
  user: userPublicKey,
  priceImpact: new BN(50), // 0.5% max price impact
  binArraysPubkey: binArrays.map(b => b.publicKey)
});

async swap({
    inToken,
    outToken,
    inAmount,
    minOutAmount,
    lbPair,
    user,
    binArraysPubkey,
}: SwapParams): Promise<Transaction>

inToken: PublicKey            // The public key of input token mint
outToken: PublicKey           // The public key of output token mint
inAmount: BN                  // Amount of input token to swap
minOutAmount: BN              // Minimum amount of output token expected
lbPair: PublicKey             // The public key of the liquidity pool
user: PublicKey               // The public key of the user account
binArraysPubkey: PublicKey[]  // Array of bin arrays involved in swap

// Execute swap
const swapTx = await dlmmPool.swap({
  inToken: tokenXMint,
  outToken: tokenYMint,
  inAmount: new BN(1000000),
  minOutAmount: new BN(950000), // accounting for slippage
  lbPair: dlmmPool.pubkey,
  user: userPublicKey,
  binArraysPubkey: swapQuote.binArraysPubkey
});

async claimLMReward({
    owner,
    position,
}: {
    owner: PublicKey;
    position: LbPosition;
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the position owner
position: LbPosition          // The position object containing position data

// Claim LM rewards for a position
const position = await dlmmPool.getPosition(positionPublicKey);
const claimTxs = await dlmmPool.claimLMReward({
  owner: userPublicKey,
  position
});

async claimAllLMRewards({
    owner,
    positions,
}: {
    owner: PublicKey;
    positions: LbPosition[];
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the positions owner
positions: LbPosition[]       // Array of position objects

const positions = await dlmmPool.getPositionsByUserAndLbPair(userPublicKey);
const claimTxs = await dlmmPool.claimAllLMRewards({
  owner: userPublicKey,
  positions: positions.userPositions
});

async claimSwapFee({
    owner,
    position,
}: {
    owner: PublicKey;
    position: LbPosition;
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the position owner
position: LbPosition          // The position object containing position data

const position = await dlmmPool.getPosition(positionPublicKey);
const claimFeeTxs = await dlmmPool.claimSwapFee({
  owner: userPublicKey,
  position
});

async claimAllSwapFee({
    owner,
    positions,
}: {
    owner: PublicKey;
    positions: LbPosition[];
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the positions owner
positions: LbPosition[]       // Array of position objects

// Claim all swap fees for user positions
const positions = await dlmmPool.getPositionsByUserAndLbPair(userPublicKey);
const claimFeeTxs = await dlmmPool.claimAllSwapFee({
  owner: userPublicKey,
  positions: positions.userPositions
});

async claimAllRewards({
    owner,
    positions,
}: {
    owner: PublicKey;
    positions: LbPosition[];
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the positions owner
positions: LbPosition[]       // Array of position objects

const positions = await dlmmPool.getPositionsByUserAndLbPair(userPublicKey);
const claimAllTxs = await dlmmPool.claimAllRewards({
  owner: userPublicKey,
  positions: positions.userPositions
});

async claimAllRewardsByPosition({
    owner,
    position,
}: {
    owner: PublicKey;
    position: LbPosition;
}): Promise<Transaction[]>

owner: PublicKey              // The public key of the position owner
position: LbPosition          // The position object to claim rewards for

// Claim all rewards for a specific position
const position = await dlmmPool.getPosition(positionPublicKey);
const claimAllTxs = await dlmmPool.claimAllRewardsByPosition({
  owner: userPublicKey,
  position
});

async closePosition({
    owner,
    position,
}: {
    owner: PublicKey;
    position: LbPosition;
}): Promise<Transaction>

owner: PublicKey              // The public key of the position owner
position: LbPosition          // The position object to close

// Close a position
const position = await dlmmPool.getPosition(positionPublicKey);
const closeTx = await dlmmPool.closePosition({
  owner: userPublicKey,
  position
});

async closePositionIfEmpty({
    owner,
    position,
}: {
    owner: PublicKey;
    position: LbPosition;
}): Promise<Transaction>

owner: PublicKey              // The public key of the position owner
position: LbPosition          // The position object to close

// Close position if empty
const position = await dlmmPool.getPosition(positionPublicKey);
const closeTx = await dlmmPool.closePositionIfEmpty({
  owner: userPublicKey,
  position
});

async quoteCreatePosition({ strategy }: TQuoteCreatePositionParams)

strategy: StrategyParameters  // Strategy parameters containing min/max bin IDs

// Quote position creation cost
const quote = await dlmmPool.quoteCreatePosition({
  strategy: {
    minBinId: 8388600,
    maxBinId: 8388620,
    strategyType: StrategyType.SpotBalanced,
  }
});

async createEmptyPosition({
    positionPubKey,
    minBinId,
    maxBinId,
    user,
}: {
    positionPubKey: PublicKey;
    minBinId: number;
    maxBinId: number;
    user: PublicKey;
})

positionPubKey: PublicKey     // The public key of the position account
minBinId: number              // Lower bin ID of the position
maxBinId: number              // Upper bin ID of the position
user: PublicKey               // The public key of the user account

const positionKeypair = Keypair.generate();
const createTx = await dlmmPool.createEmptyPosition({
  positionPubKey: positionKeypair.publicKey,
  minBinId: 8388600,
  maxBinId: 8388620,
  user: userPublicKey
});

async seedLiquidity(
    owner: PublicKey,
    seedAmount: BN,
    curvature: number,
    minPrice: number,
    maxPrice: number,
    base: PublicKey,
    payer: PublicKey,
    feeOwner: PublicKey,
    operator: PublicKey,
    lockReleasePoint: BN,
    shouldSeedPositionOwner: boolean = false
): Promise<SeedLiquidityResponse>

owner: PublicKey              // The public key of the positions owner
seedAmount: BN                // Lamport amount to be seeded to the pool
curvature: number             // Distribution curvature parameter
minPrice: number              // Start price in UI format
maxPrice: number              // End price in UI format
base: PublicKey               // Base key for position derivation
payer: PublicKey              // Account rental fee payer
feeOwner: PublicKey           // Fee owner key
operator: PublicKey           // Operator key
lockReleasePoint: BN          // Timelock point for position withdrawal
shouldSeedPositionOwner?: boolean // Whether to send token to position owner

const curvature = 0.6;
const minPrice = 0.000001;
const maxPrice = 0.00003;

const currentSlot = await connection.getSlot();
const lockDuration = new BN(86400 * 31);
const lockReleaseSlot = lockDuration.add(new BN(currentSlot));

const seedResponse = await dlmmPool.seedLiquidity(
  ownerPublicKey,
  new BN(200_000_000_000), 
  curvature, 
  minPrice, 
  maxPrice, 
  baseKeypair.publicKey,
  payerPublicKey,
  feeOwnerPublicKey,
  operatorPublicKey,
  lockReleaseSlot,
  true 
);

async seedLiquiditySingleBin(
    payer: PublicKey,
    base: PublicKey,
    seedAmount: BN,
    price: number,
    roundingUp: boolean,
    positionOwner: PublicKey,
    feeOwner: PublicKey,
    operator: PublicKey,
    lockReleasePoint: BN,
    shouldSeedPositionOwner: boolean = false
): Promise<SeedLiquiditySingleBinResponse>

payer: PublicKey              // The public key of the tx payer
base: PublicKey               // Base key for position derivation
seedAmount: BN                // Token X lamport amount to be seeded
price: number                 // TokenX/TokenY Price in UI format
roundingUp: boolean           // Whether to round up the price
positionOwner: PublicKey      // The owner of the position
feeOwner: PublicKey           // Position fee owner
operator: PublicKey           // Operator of the position
lockReleasePoint: BN          // The lock release point of the position
shouldSeedPositionOwner?: boolean // Whether to send token to position owner

const initialPrice = 0.000001;

const seedResponse = await dlmmPool.seedLiquiditySingleBin(
  payerPublicKey,
  baseKeypair.publicKey,
  new BN(1000000), 
  initialPrice, 
  true,
  ownerPublicKey,
  feeOwnerPublicKey,
  operatorPublicKey,
  new BN(Date.now() / 1000 + 86400) 
);

async initializeBinArrays(binArrayIndexes: BN[], funder: PublicKey)

binArrayIndexes: BN[]         // Array of bin array indexes to initialize
funder: PublicKey             // The public key of the funder

// Initialize specific bin arrays
const binArrayIndexes = [new BN(-1), new BN(0), new BN(1)];
const instructions = await dlmmPool.initializeBinArrays(
  binArrayIndexes,
  funderPublicKey
);

async initializePositionByOperator({
    lowerBinId,
    positionWidth,
    owner,
    feeOwner,
    base,
    operator,
    payer,
    lockReleasePoint,
}: {
    lowerBinId: BN;
    positionWidth: BN;
    owner: PublicKey;
    feeOwner: PublicKey;
    operator: PublicKey;
    payer: PublicKey;
    base: PublicKey;
    lockReleasePoint: BN;
}): Promise<Transaction>

lowerBinId: BN                // Lower bin ID of the position
positionWidth: BN             // Width of the position
owner: PublicKey              // Owner of the position
feeOwner: PublicKey           // Owner of the fees earned by the position
operator: PublicKey           // Operator of the position
payer: PublicKey              // Payer for the position account rental
base: PublicKey               // Base key for position derivation
lockReleasePoint: BN          // The lock release point of the position

const initTx = await dlmmPool.initializePositionByOperator({
  lowerBinId: new BN(5660),
  positionWidth: MAX_BIN_PER_POSITION,
  owner: ownerPublicKey,
  feeOwner: feeOwnerPublicKey,
  operator: operatorPublicKey,
  payer: payerPublicKey,
  base: baseKeypair.publicKey,
  lockReleasePoint: new BN(Date.now() / 1000 + 86400)
});

async setPairStatusPermissionless(
    enable: boolean,
    creator: PublicKey
)

enable: boolean               // If true, enables the pair; if false, disables it
creator: PublicKey            // The public key of the pool creator

const statusTx = await dlmmPool.setPairStatusPermissionless(
  true, 
  creatorPublicKey
);

async setActivationPoint(activationPoint: BN)

activationPoint: BN           // The activation point (timestamp/slot)

const activationTx = await dlmmPool.setActivationPoint(
  new BN(Date.now() / 1000 + 3600)
);

async setPairStatus(enabled: boolean): Promise<Transaction>

enabled: boolean              // Whether to enable or disable the pair

const statusTx = await dlmmPool.setPairStatus(true); // enable

static async getLbPairs(
    connection: Connection,
    opt?: Opt
): Promise<LbPairAccount[]>

connection: Connection        // Solana connection instance
opt?: Opt                     // Optional cluster and program ID

const allPairs = await DLMM.getLbPairs(connection);

static async getCustomizablePermissionlessLbPairIfExists(
    connection: Connection,
    tokenX: PublicKey,
    tokenY: PublicKey,
    opt?: Opt
): Promise<PublicKey | null>

connection: Connection        // Solana connection instance
tokenX: PublicKey             // Token X mint address
tokenY: PublicKey             // Token Y mint address
opt?: Opt                     // Optional parameters

const WEN = new PublicKey('WENWENvqqNya429ubCdR81ZmD69brwQaaBYY6p3LCpk')
const USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

const pairPubkey = await DLMM.getCustomizablePermissionlessLbPairIfExists(
  connection,
  WEN,
  USDC,
  {
    cluster: "localhost",
  }
);

async getPosition(positionPubKey: PublicKey): Promise<LbPosition>

positionPubKey: PublicKey     // The public key of the position account

const position = await dlmmPool.getPosition(positionPublicKey);

static async getAllPresetParameters(
    connection: Connection, 
    opt?: Opt
): Promise<{
    presetParameter: PresetParameterAccount[];
    presetParameter2: PresetParameter2Account[];
}>

connection: Connection         // Solana connection instance
opt?: Opt                     // Optional cluster and program ID

const presetParams = await DLMM.getAllPresetParameters(connection);

static async getAllLbPairPositionsByUser(
    connection: Connection,
    userPubKey: PublicKey,
    opt?: Opt,
    getPositionsOpt?: GetPositionsOpt
): Promise<Map<string, PositionInfo>>