DLMM TypeScript SDK Methods Reference - Saros Finance Developer Hub

SDK Version: v1.4.0+ | Class: LiquidityBookServices | Import: @saros-finance/dlmm-sdk

Core Trading Methods

`quote(params: GetTokenOutputParams): Promise<GetTokenOutputResponse>`

Calculates swap quote for DLMM concentrated liquidity pools using pool metadata. Parameters:

params.amount (number) - Input amount in smallest token units
params.metadata (PoolMetadata) - Pool metadata from fetchPoolMetadata()
params.optional.isExactInput (boolean) - true = exact input, false = exact output
params.optional.swapForY (boolean) - Direction: true = X→Y, false = Y→X
params.optional.slippage (number) - Slippage percentage (0.5 = 0.5%)

Returns: Promise<GetTokenOutputResponse>

amountIn (bigint) - Required input amount
amountOut (bigint) - Expected output amount
priceImpact (number) - Price impact percentage
amount (bigint) - Amount for transaction (exact input or slippage-adjusted)
otherAmountOffset (bigint) - Slippage-adjusted amount (min out for exact input)

Example:

import { LiquidityBookServices, MODE } from '@saros-finance/dlmm-sdk';

const dlmmService = new LiquidityBookServices({
  mode: MODE.MAINNET,
  options: { rpcUrl: "https://api.mainnet-beta.solana.com" }
});

// First get pool metadata
const metadata = await dlmmService.fetchPoolMetadata("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5");

// Then get quote
const quote = await dlmmService.quote({
  amount: 1_000_000, // 1 USDC (6 decimals)
  metadata,
  optional: {
    isExactInput: true,
    swapForY: true,
    slippage: 0.5
  }
});

Throws:

Error("Pair not found") - Invalid pool address
Error("Swap crosses too many bins") - Insufficient liquidity
Error("Invalid amount") - Amount is zero or negative
Error("Token account not found") - Missing associated token account

Pool Data Methods

`fetchPoolMetadata(poolAddress: string): Promise<PoolMetadata>`

Fetches complete metadata for a DLMM pool including tokens, decimals, reserves. Parameters:

poolAddress (string) - The pool address to fetch metadata for

Returns: Promise<PoolMetadata>

poolAddress (string) - Pool address
baseMint (string) - Base token mint address
quoteMint (string) - Quote token mint address
extra.tokenBaseDecimal (number) - Base token decimals
extra.tokenQuoteDecimal (number) - Quote token decimals
baseReserve (string) - Base token reserve amount
quoteReserve (string) - Quote token reserve amount

Example:

const metadata = await dlmmService.fetchPoolMetadata("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5");
console.log(`Pool: ${metadata.baseMint}/${metadata.quoteMint}`);
console.log(`Decimals: ${metadata.extra.tokenBaseDecimal}/${metadata.extra.tokenQuoteDecimal}`);

`getPairAccount(pair: PublicKey): Promise<PairAccount>`

Gets the pair account data for a DLMM pool. Parameters:

pair (PublicKey) - Pool public key

Returns: Promise<PairAccount>

activeId (number) - Current active bin ID
binStep (number) - Bin step size

`getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<BinArrayInfo>`

Fetches bin array information including liquidity distribution. Parameters:

params.binArrayIndex (number) - Bin array index to fetch
params.pair (PublicKey) - Pool public key
params.payer (PublicKey) - Payer public key

Returns: Promise<BinArrayInfo>

bins (Bin[]) - Array of bin data
resultIndex (number) - Starting bin index

Liquidity Management Methods

`addLiquidity(params: AddLiquidityParams): Promise<Transaction>`

Adds concentrated liquidity to specified price bins in a DLMM pool. Parameters:

params.pair (PublicKey) - DLMM pool address
params.tokenX (PublicKey) - Token X mint address
params.tokenY (PublicKey) - Token Y mint address
params.binId (number) - Target bin ID for liquidity placement
params.binIds (number[], optional) - Multiple bin IDs for distribution
params.amounts (LiquidityAmount[]) - Liquidity amounts per bin
params.wallet (PublicKey) - User’s wallet public key
params.activeId (number) - Current active bin ID
params.maxBinStep (number) - Maximum bin step for slippage protection

Returns: Promise<Transaction> Example:

const transaction = await dlmm.addLiquidity({
  pair: poolAddress,
  tokenX: solMint,
  tokenY: usdcMint,
  binIds: [8388608, 8388609, 8388610],
  amounts: [
    { binId: 8388608, amountX: BigInt("100000000"), amountY: BigInt("0") },
    { binId: 8388609, amountX: BigInt("50000000"), amountY: BigInt("50000000") },
    { binId: 8388610, amountX: BigInt("0"), amountY: BigInt("100000000") }
  ],
  wallet: wallet.publicKey,
  activeId: 8388609,
  maxBinStep: 10
});

Error Codes:

INVALID_BIN_ID - Bin ID outside valid range
INSUFFICIENT_AMOUNT - Liquidity amount too small
BIN_ARRAY_NOT_INITIALIZED - Target bin array needs initialization
PRICE_OUT_OF_RANGE - Bin price exceeds pool limits

`removeLiquidity(params: RemoveLiquidityParams): Promise<Transaction>`

Removes liquidity from specified bins and claims earned fees. Parameters:

params.pair (PublicKey) - DLMM pool address
params.binIds (number[]) - Bin IDs to remove liquidity from
params.liquidityShares (LiquidityShare[]) - LP shares to remove per bin
params.wallet (PublicKey) - User’s wallet public key
params.shouldClaimAndClose? (boolean, optional) - Whether to close empty positions

Returns: Promise<Transaction> Example:

const transaction = await dlmm.removeLiquidity({
  pair: poolAddress,
  binIds: [8388608, 8388609],
  liquidityShares: [
    { binId: 8388608, share: BigInt("500000") },
    { binId: 8388609, share: BigInt("750000") }
  ],
  wallet: wallet.publicKey,
  shouldClaimAndClose: true
});

Pool Information Methods

`getPoolState(poolAddress: PublicKey): Promise<PoolState>`

Retrieve complete pool state including bins, reserves, and fees. Parameters:

poolAddress (PublicKey) - DLMM pool address

Returns: Promise<PoolState>

tokenX (PublicKey) - Token X mint
tokenY (PublicKey) - Token Y mint
binStep (number) - Bin step (basis points)
activeId (number) - Current active bin ID
reserveX (bigint) - Total reserve of token X
reserveY (bigint) - Total reserve of token Y
totalSupply (bigint) - Total LP token supply
feeParameters (FeeParameters) - Fee configuration
volatilityAccumulator (number) - Volatility tracking for dynamic fees
protocolFee (number) - Protocol fee percentage

Example:

const poolState = await dlmm.getPoolState(poolAddress);

console.log(`Active Bin: ${poolState.activeId}`);
console.log(`Current Price: ${poolState.currentPrice}`);
console.log(`Total TVL: $${poolState.tvl.toLocaleString()}`);
console.log(`24h Volume: $${poolState.volume24h.toLocaleString()}`);

`getBinData(poolAddress: PublicKey, binId: number): Promise<BinData>`

Get detailed information about a specific liquidity bin. Parameters:

poolAddress (PublicKey) - DLMM pool address
binId (number) - Bin ID to query

Returns: Promise<BinData>

binId (number) - Bin identifier
price (number) - Bin price in token Y per token X
liquidityX (bigint) - Token X liquidity in bin
liquidityY (bigint) - Token Y liquidity in bin
totalLiquidity (bigint) - Total liquidity in bin
feeAmountX (bigint) - Accumulated fees for token X
feeAmountY (bigint) - Accumulated fees for token Y
lpSupply (bigint) - LP token supply for this bin

Example:

const binData = await dlmm.getBinData(poolAddress, 8388608);

if (binData.totalLiquidity > 0) {
  console.log(`Bin ${binData.binId} has ${binData.totalLiquidity} liquidity`);
  console.log(`Price: $${binData.price.toFixed(4)}`);
  console.log(`Fees earned: ${binData.feeAmountX} X, ${binData.feeAmountY} Y`);
}

Utility Methods

`findBestPairs(tokenA: PublicKey, tokenB: PublicKey): Promise<PairInfo[]>`

Discover all DLMM pools for a token pair, sorted by liquidity. Parameters:

tokenA (PublicKey) - First token mint
tokenB (PublicKey) - Second token mint

Returns: Promise<PairInfo[]>

Array of pools sorted by TVL (highest first)
Each entry contains: address, binStep, tvl, volume24h, apy

Example:

const pairs = await dlmm.findBestPairs(solMint, usdcMint);

console.log(`Found ${pairs.length} pools for SOL/USDC:`);
pairs.forEach((pair, index) => {
  console.log(`${index + 1}. ${pair.address.slice(0, 8)}... TVL: $${pair.tvl.toLocaleString()}`);
  console.log(`   Bin Step: ${pair.binStep / 100}%, 24h Vol: $${pair.volume24h.toLocaleString()}`);
});

// Use highest TVL pool for best liquidity
const bestPool = pairs[0];

`calculateOptimalBinDistribution(params: DistributionParams): BinAllocation[]`

Calculate optimal bin allocation for concentrated liquidity provision. Parameters:

params.currentPrice (number) - Current token price
params.priceRange (PriceRange) - Desired price range
params.totalAmount (bigint) - Total liquidity amount to deploy
params.distribution (‘uniform’ | ‘normal’ | ‘custom’) - Distribution strategy
params.concentrationFactor (number, 1-10) - Liquidity concentration level

Returns: BinAllocation[]

Optimized allocation across bins
Maximizes fee capture while managing risk

Example:

const allocations = dlmm.calculateOptimalBinDistribution({
  currentPrice: 95.50,
  priceRange: { min: 90.00, max: 101.00 },
  totalAmount: BigInt("1000000000"), // 1 SOL worth
  distribution: 'normal', // Bell curve around current price
  concentrationFactor: 7 // High concentration
});

allocations.forEach(allocation => {
  console.log(`Bin ${allocation.binId}: ${allocation.percentage}% (${allocation.amount})`);
});

Error Code Reference

Error Code	Description
`PAIR_NOT_FOUND`	Pool address is invalid
`INSUFFICIENT_LIQUIDITY`	Insufficient liquidity for operation
`SLIPPAGE_EXCEEDED`	Price impact exceeds tolerance
`INVALID_BIN_ID`	Bin ID outside valid range
`WALLET_INSUFFICIENT_BALANCE`	Wallet token balance insufficient
`MISSING_TOKEN_ACCOUNT`	Associated token account does not exist
`BIN_ARRAY_NOT_INITIALIZED`	Required bin array not initialized
`PRICE_OUT_OF_RANGE`	Price exceeds pool limits
`AMOUNT_TOO_SMALL`	Amount below minimum threshold
`NETWORK_ERROR`	RPC connection failure

`swap(params: SwapParams): Promise<Transaction>`

Executes DLMM concentrated liquidity swap with optimal routing through active bins. Parameters:

params.pair (PublicKey) - DLMM pool address
params.tokenBase (PublicKey) - Source token mint address
params.tokenQuote (PublicKey) - Destination token mint address
params.amount (bigint) - Input amount in token base units
params.swapForY (boolean) - Swap direction: true = X→Y, false = Y→X
params.isExactInput (boolean) - true = exact input amount, false = exact output
params.wallet (PublicKey) - User’s wallet public key
params.slippage (number) - Maximum slippage tolerance (0.5 = 0.5%)
params.minAmountOut? (bigint, optional) - Minimum output amount (overrides slippage)
params.maxAmountIn? (bigint, optional) - Maximum input amount for exactOutput swaps

Returns: Promise<Transaction>

Pre-built transaction ready for signing
Contains swap instruction with optimal bin routing
Includes necessary account creations (ATA, etc.)

Example:

import { Connection, PublicKey, Keypair } from '@solana/web3.js';
import { LiquidityBookServices } from '@saros-finance/dlmm-sdk';

const connection = new Connection('https://api.devnet.solana.com');
const dlmm = new LiquidityBookServices(connection);
const wallet = Keypair.generate();

const transaction = await dlmm.swap({
  pair: new PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5"),
  tokenBase: new PublicKey("So11111111111111111111111111111111111111112"),
  tokenQuote: new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
  amount: BigInt("100000000"),
  swapForY: true,
  isExactInput: true,
  wallet: wallet.publicKey,
  slippage: 0.5
});

transaction.sign([wallet]);
const signature = await connection.sendRawTransaction(transaction.serialize());
await connection.confirmTransaction(signature, 'confirmed');

Error Codes:

INSUFFICIENT_LIQUIDITY - Not enough liquidity in active bins for swap size
SLIPPAGE_EXCEEDED - Price moved beyond slippage tolerance during execution
INVALID_PAIR - Pool address does not exist or is not a valid DLMM pair
TOKEN_MISMATCH - Token mints don’t match the pool’s token pair
AMOUNT_TOO_SMALL - Input amount below minimum swap threshold (typically 1000 units)
AMOUNT_TOO_LARGE - Input amount would cause excessive price impact (>50%)
BIN_ARRAY_NOT_FOUND - Required bin arrays for swap path are not initialized
WALLET_INSUFFICIENT_BALANCE - User’s token account has insufficient balance
MISSING_TOKEN_ACCOUNT - Required associated token account doesn’t exist

Gas Usage: ~15,000-25,000 compute units (varies by number of bins traversed) Network Requirements: Devnet/Mainnet-beta compatible

Creates swap transaction for DLMM pool execution. Parameters:

params.tokenMintX (PublicKey) - X token mint
params.tokenMintY (PublicKey) - Y token mint
params.amount (bigint) - Swap amount in token units
params.otherAmountOffset (bigint) - Minimum output (from quote)
params.swapForY (boolean) - Swap direction
params.isExactInput (boolean) - Input type
params.pair (PublicKey) - Pool address
params.hook (PublicKey) - Hook program address
params.payer (PublicKey) - Transaction payer

Returns: Promise<Transaction> - Ready-to-send transaction Example:

const transaction = await dlmm.swap({
  tokenMintX: new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
  tokenMintY: new PublicKey("So11111111111111111111111111111111111111112"),
  amount: BigInt("1000000"),
  otherAmountOffset: quote.otherAmountOffset,
  swapForY: true,
  isExactInput: true,
  pair: new PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5"),
  hook: hookAddress,
  payer: wallet.publicKey
});

const signature = await sendTransaction(transaction, connection);

Throws:

Error("Pair not found") - Invalid pool
Error("No valid bin arrays found") - Liquidity unavailable

Pool Management Methods

`fetchPoolMetadata(pair: string): Promise<PoolMetadata>`

Fetches comprehensive pool metadata and current state. Parameters:

pair (string) - Pool address as string

Returns: Promise<PoolMetadata>

poolAddress (string) - Pool address
baseMint (string) - Base token mint
baseReserve (string) - Base token reserve
quoteMint (string) - Quote token mint
quoteReserve (string) - Quote token reserve
tradeFee (number) - Current trading fee rate
extra.hook (string, optional) - Hook address if present
extra.tokenBaseDecimal (number) - Base token decimals
extra.tokenQuoteDecimal (number) - Quote token decimals

Example:

const metadata = await dlmm.fetchPoolMetadata("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5");
console.log(`Trading fee: ${metadata.tradeFee}%`);
console.log(`TVL: ${metadata.baseReserve} + ${metadata.quoteReserve}`);

`fetchPoolAddresses(): Promise<string[]>`

Retrieves all DLMM pool addresses for the current program. Returns: Promise<string[]> - Array of pool addresses Example:

const pools = await dlmm.fetchPoolAddresses();
console.log(`Found ${pools.length} DLMM pools`);

Throws:

Error("Pair account not found") - Program account issue
Error("Pair not found") - No pools exist

Position Management Methods

`createPosition(params: CreatePositionParams): Promise<{position: string}>`

Creates a new concentrated liquidity position. Parameters:

params.payer (PublicKey) - Position creator and payer
params.relativeBinIdLeft (number) - Left bin boundary (relative)
params.relativeBinIdRight (number) - Right bin boundary (relative)
params.pair (PublicKey) - Target pool address
params.binArrayIndex (number) - Bin array index for position
params.positionMint (PublicKey) - Position NFT mint
params.transaction (Transaction) - Transaction to add instructions

Returns: Promise<{position: string}> - Created position address Example:

const result = await dlmm.createPosition({
  payer: wallet.publicKey,
  relativeBinIdLeft: -10,
  relativeBinIdRight: 10,
  pair: poolAddress,
  binArrayIndex: currentBinArrayIndex,
  positionMint: newPositionMint,
  transaction: tx
});

`addLiquidityIntoPosition(params: AddLiquidityIntoPositionParams): Promise<void>`

Adds liquidity to an existing position with distribution across bins. Parameters:

params.positionMint (PublicKey) - Position NFT mint
params.payer (PublicKey) - Liquidity provider
params.pair (PublicKey) - Pool address
params.binArrayLower (PublicKey) - Lower bin array
params.binArrayUpper (PublicKey) - Upper bin array
params.transaction (Transaction) - Transaction object
params.liquidityDistribution (Distribution[]) - Liquidity per bin
params.amountX (number) - X token amount
params.amountY (number) - Y token amount

Example:

await dlmm.addLiquidityIntoPosition({
  positionMint,
  payer: wallet.publicKey,
  pair: poolAddress,
  binArrayLower,
  binArrayUpper,
  transaction: tx,
  liquidityDistribution: [
    { relativeBinId: -2, distributionX: 2000, distributionY: 0 },
    { relativeBinId: -1, distributionX: 3000, distributionY: 2000 },
    { relativeBinId: 0, distributionX: 5000, distributionY: 5000 },
    { relativeBinId: 1, distributionX: 0, distributionY: 3000 }
  ],
  amountX: 1000000000,
  amountY: 10000000000
});

`getUserPositions(params: UserPositionsParams): Promise<PositionInfo[]>`

Retrieves all positions owned by a user for a specific pool. Parameters:

params.payer (PublicKey) - User wallet address
params.pair (PublicKey) - Pool to query positions for

Returns: Promise<PositionInfo[]> - Array of position information

pair (string) - Pool address
positionMint (string) - Position NFT mint
position (string) - Position account address
liquidityShares (string[]) - Liquidity shares per bin
lowerBinId (number) - Lower bin boundary
upperBinId (number) - Upper bin boundary
space (number[]) - Reserved space

Example:

const positions = await dlmm.getUserPositions({
  payer: wallet.publicKey,
  pair: poolAddress
});

positions.forEach(pos => {
  console.log(`Position range: ${pos.lowerBinId} to ${pos.upperBinId}`);
});

`removeMultipleLiquidity(params: RemoveMultipleLiquidityParams): Promise<RemoveMultipleLiquidityResponse>`

Removes liquidity from multiple positions with batched transactions. Parameters:

params.maxPositionList - Array of positions to process:
- position (string) - Position account address
- start (number) - Start bin ID
- end (number) - End bin ID
- positionMint (string) - Position NFT mint
params.payer (PublicKey) - Transaction payer
params.type (“removeBoth” | “removeBaseToken” | “removeQuoteToken”) - Removal type
params.pair (PublicKey) - Pool address
params.tokenMintX (PublicKey) - X token mint
params.tokenMintY (PublicKey) - Y token mint
params.activeId (number) - Current active bin ID

Returns: Promise<RemoveMultipleLiquidityResponse>

txs (Transaction[]) - Array of removal transactions
txCreateAccount (Transaction, optional) - Account creation transaction
txCloseAccount (Transaction, optional) - Account closure transaction
positionClosed (ClosedPosition[], optional) - Closed positions

Example:

const result = await dlmm.removeMultipleLiquidity({
  maxPositionList: [
    { position: "pos1", start: -10, end: 10, positionMint: "mint1" }
  ],
  payer: wallet.publicKey,
  type: "removeBoth",
  pair: poolAddress,
  tokenMintX: usdcMint,
  tokenMintY: solMint,
  activeId: currentActiveId
});

Bin Array Management

`getBinArray(params: GetBinArrayParams): Promise<PublicKey>`

Gets bin array address and optionally initializes if needed. Parameters:

params.binArrayIndex (number) - Bin array index
params.pair (PublicKey) - Pool address
params.payer (PublicKey, optional) - Payer for initialization
params.transaction (Transaction, optional) - Transaction to add init instruction

Returns: Promise<PublicKey> - Bin array address Example:

const binArrayAddress = await dlmm.getBinArray({
  binArrayIndex: 0,
  pair: poolAddress,
  payer: wallet.publicKey,
  transaction: tx
});

`getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<{bins: any[], resultIndex: number}>`

Retrieves bin information from surrounding bin arrays. Parameters:

params.binArrayIndex (number) - Target bin array index
params.pair (PublicKey) - Pool address
params.payer (PublicKey) - Query executor

Returns: Promise<{bins: any[], resultIndex: number}>

bins - Array of bin data from surrounding arrays
resultIndex - Actual starting index used

Example:

const { bins, resultIndex } = await dlmm.getBinArrayInfo({
  binArrayIndex: 0,
  pair: poolAddress,
  payer: wallet.publicKey
});

`getBinsReserveInformation(params: GetBinsReserveParams): Promise<GetBinsReserveResponse[]>`

Gets detailed reserve information for all bins in a position. Parameters:

params.position (PublicKey) - Position account address
params.pair (PublicKey) - Pool address
params.payer (PublicKey) - Query executor

Returns: Promise<GetBinsReserveResponse[]> - Array of bin reserves

reserveX (string | number) - X token reserve in bin
reserveY (string | number) - Y token reserve in bin
totalSupply (string | number) - Total liquidity supply in bin
liquidityShare (BN) - User’s share of bin liquidity
binId (number) - Bin identifier
binPosistion (number) - Position within bin array

Example:

const reserves = await dlmm.getBinsReserveInformation({
  position: positionAddress,
  pair: poolAddress,
  payer: wallet.publicKey
});

reserves.forEach(reserve => {
  console.log(`Bin ${reserve.binId}: ${reserve.reserveX}x${reserve.reserveY}`);
});

Pool Creation Methods

`createPairWithConfig(params: CreatePairWithConfigParams): Promise<PairCreationResult>`

Creates a new DLMM pool with specified configuration. Parameters:

params.tokenBase - Base token configuration:
- decimal (number) - Token decimals
- mintAddress (string) - Token mint address
params.tokenQuote - Quote token configuration:
- decimal (number) - Token decimals
- mintAddress (string) - Token mint address
params.binStep (number) - Price step between bins
params.ratePrice (number) - Initial price rate
params.payer (PublicKey) - Pool creator and payer

Returns: Promise<PairCreationResult>

tx (Transaction) - Pool creation transaction
pair (string) - Created pool address
binArrayLower (string) - Lower bin array address
binArrayUpper (string) - Upper bin array address
hooksConfig (string) - Hooks configuration address
activeBin (number) - Initial active bin ID

Example:

const result = await dlmm.createPairWithConfig({
  tokenBase: { decimal: 6, mintAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" },
  tokenQuote: { decimal: 9, mintAddress: "So11111111111111111111111111111111111111112" },
  binStep: 25, // 0.25% step
  ratePrice: 100, // 1 USDC = 0.01 SOL
  payer: wallet.publicKey
});

Utility Methods

`getDexName(): string`

Returns the DEX identifier string. Returns: "Saros DLMM"

`getDexProgramId(): PublicKey`

Returns the DLMM program ID for current configuration. Returns: PublicKey - Program identifier

`quote(params: QuickQuoteParams): Promise<GetTokenOutputResponse>`

Simplified quote method using pool metadata. Parameters:

params.amount (number) - Input amount
params.metadata (PoolMetadata) - Pool metadata object
params.optional - Quote options:
- isExactInput (boolean) - Input precision type
- swapForY (boolean) - Swap direction
- slippage (number) - Slippage tolerance

Returns: Promise<GetTokenOutputResponse> - Same as getQuote Example:

const quickQuote = await dlmm.quote({
  amount: 1000000,
  metadata: poolMetadata,
  optional: {
    isExactInput: true,
    swapForY: true,
    slippage: 0.5
  }
});

Account Management Methods

`getPairVaultInfo(params: VaultInfoParams): Promise<PublicKey>`

Gets or creates token vault account for pool. Parameters:

params.tokenAddress (PublicKey) - Token mint address
params.pair (PublicKey) - Pool address
params.payer (PublicKey, optional) - Account creator
params.transaction (Transaction, optional) - Transaction for creation

Returns: Promise<PublicKey> - Vault account address

`getUserVaultInfo(params: GetUserVaultInfoParams): Promise<PublicKey>`

Gets or creates user token account. Parameters:

params.tokenAddress (PublicKey) - Token mint
params.payer (PublicKey) - User wallet
params.transaction (Transaction, optional) - Transaction for creation

Returns: Promise<PublicKey> - User token account address

Event Subscription Methods

`listenNewPoolAddress(postTxFunction: (address: string) => Promise<void>): void`

Subscribes to new pool creation events. Parameters:

postTxFunction (Function) - Callback for new pool addresses

Example:

dlmm.listenNewPoolAddress(async (poolAddress) => {
  console.log(`New pool created: ${poolAddress}`);
  await updatePoolList(poolAddress);
});

Advanced Calculation Methods (LBSwapService)

`calculateInOutAmount(params: GetTokenOutputParams): Promise<{amountIn: bigint, amountOut: bigint}>`

Core calculation engine for swap amounts across bins. Internal Method - Used by getQuote() for precise calculations

`calculateAmountOut(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>`

Calculates exact output for exact input swaps. Internal Method - Handles bin traversal and fee calculations

`calculateAmountIn(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>`

Calculates required input for exact output swaps. Internal Method - Reverse calculation with fee adjustments

Error Handling

Standard Error Types

NetworkError

Cause: RPC connection failures or timeouts
Code: NETWORK_ERROR

InsufficientLiquidityError

Cause: Not enough liquidity in requested bins
Code: INSUFFICIENT_LIQUIDITY

SlippageExceededError

Cause: Price impact exceeds tolerance
Code: SLIPPAGE_EXCEEDED

InvalidParameterError

Cause: Invalid addresses, amounts, or configurations
Code: INVALID_PARAMETER

Performance Characteristics

Method Performance

Method	Avg Latency	Rate Limit	Caching
`getQuote`	200-400ms	100/min	None
`fetchPoolMetadata`	150-300ms	100/min	30s
`fetchPoolAddresses`	1-3s	10/min	5min
`swap`	400-800ms	10/min	None
`getUserPositions`	800-1200ms	20/min	None

Network Configuration

Devnet Configuration

const dlmm = new LiquidityBookServices({
  mode: MODE.DEVNET,
  options: {
    rpcUrl: "https://api.devnet.solana.com",
    commitmentOrConfig: "confirmed"
  }
});

Mainnet Configuration

const dlmm = new LiquidityBookServices({
  mode: MODE.MAINNET,
  options: {
    rpcUrl: "https://api.mainnet-beta.solana.com", 
    commitmentOrConfig: "confirmed"
  }
});

Quick Reference Table

Method	Purpose	Primary Use Case	Returns
`getQuote`	Get swap pricing	Price discovery	Quote with slippage
`swap`	Execute swap	Token trading	Transaction
`fetchPoolMetadata`	Pool information	Pool analysis	Comprehensive metadata
`createPosition`	Create LP position	Liquidity provision	Position address
`addLiquidityIntoPosition`	Add liquidity	Position management	Transaction update
`getUserPositions`	Query positions	Portfolio tracking	Position array
`removeMultipleLiquidity`	Remove liquidity	Position exit	Transaction batch
`fetchPoolAddresses`	Discover pools	Pool exploration	Address array

Reference Documentation

DLMM Types → - Complete type definitions and interfaces
API Overview → - SDK architecture and design patterns

Getting Started (Tutorials)

DLMM Quick Start → - Build your first concentrated liquidity app
First Trading App → - Complete React trading interface
Swap Tutorial → - Add DLMM swaps to existing apps

Solve Problems (How-To Guides)

Execute Swaps → - Production swap implementation
Manage Positions → - Add/remove concentrated liquidity
Analytics Queries → - Pool performance analysis
React Integration → - React hooks and components

Understanding Concepts (Explanation)

Concentrated Liquidity → - DLMM concepts and strategies
DLMM vs Traditional AMMs → - Comparative analysis

Quick Start

Integration Tutorials

Production Examples

How-to Guides

API Reference

​Core Trading Methods

​quote(params: GetTokenOutputParams): Promise<GetTokenOutputResponse>

​Pool Data Methods

​fetchPoolMetadata(poolAddress: string): Promise<PoolMetadata>

​getPairAccount(pair: PublicKey): Promise<PairAccount>

​getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<BinArrayInfo>

​Liquidity Management Methods

​addLiquidity(params: AddLiquidityParams): Promise<Transaction>

​removeLiquidity(params: RemoveLiquidityParams): Promise<Transaction>

​Pool Information Methods

​getPoolState(poolAddress: PublicKey): Promise<PoolState>

​getBinData(poolAddress: PublicKey, binId: number): Promise<BinData>

​Utility Methods

​findBestPairs(tokenA: PublicKey, tokenB: PublicKey): Promise<PairInfo[]>

​calculateOptimalBinDistribution(params: DistributionParams): BinAllocation[]

​Error Code Reference

​swap(params: SwapParams): Promise<Transaction>

​Pool Management Methods

​fetchPoolMetadata(pair: string): Promise<PoolMetadata>

​fetchPoolAddresses(): Promise<string[]>

​Position Management Methods

​createPosition(params: CreatePositionParams): Promise<{position: string}>

​addLiquidityIntoPosition(params: AddLiquidityIntoPositionParams): Promise<void>

​getUserPositions(params: UserPositionsParams): Promise<PositionInfo[]>

​removeMultipleLiquidity(params: RemoveMultipleLiquidityParams): Promise<RemoveMultipleLiquidityResponse>

​Bin Array Management

​getBinArray(params: GetBinArrayParams): Promise<PublicKey>

​getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<{bins: any[], resultIndex: number}>

​getBinsReserveInformation(params: GetBinsReserveParams): Promise<GetBinsReserveResponse[]>

​Pool Creation Methods

​createPairWithConfig(params: CreatePairWithConfigParams): Promise<PairCreationResult>

​Utility Methods

​getDexName(): string

​getDexProgramId(): PublicKey

​quote(params: QuickQuoteParams): Promise<GetTokenOutputResponse>

​Account Management Methods

​getPairVaultInfo(params: VaultInfoParams): Promise<PublicKey>

​getUserVaultInfo(params: GetUserVaultInfoParams): Promise<PublicKey>

​Event Subscription Methods

​listenNewPoolAddress(postTxFunction: (address: string) => Promise<void>): void

​Advanced Calculation Methods (LBSwapService)

​calculateInOutAmount(params: GetTokenOutputParams): Promise<{amountIn: bigint, amountOut: bigint}>

​calculateAmountOut(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>

​calculateAmountIn(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>

​Error Handling

​Standard Error Types

​Performance Characteristics

​Method Performance

​Network Configuration

​Devnet Configuration

​Mainnet Configuration

​Quick Reference Table

​Navigation

​Reference Documentation

​Getting Started (Tutorials)

​Solve Problems (How-To Guides)

​Understanding Concepts (Explanation)

Core Trading Methods

`quote(params: GetTokenOutputParams): Promise<GetTokenOutputResponse>`

Pool Data Methods

`fetchPoolMetadata(poolAddress: string): Promise<PoolMetadata>`

`getPairAccount(pair: PublicKey): Promise<PairAccount>`

`getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<BinArrayInfo>`

Liquidity Management Methods

`addLiquidity(params: AddLiquidityParams): Promise<Transaction>`

`removeLiquidity(params: RemoveLiquidityParams): Promise<Transaction>`

Pool Information Methods

`getPoolState(poolAddress: PublicKey): Promise<PoolState>`

`getBinData(poolAddress: PublicKey, binId: number): Promise<BinData>`

Utility Methods

`findBestPairs(tokenA: PublicKey, tokenB: PublicKey): Promise<PairInfo[]>`

`calculateOptimalBinDistribution(params: DistributionParams): BinAllocation[]`

Error Code Reference

`swap(params: SwapParams): Promise<Transaction>`

Pool Management Methods

`fetchPoolMetadata(pair: string): Promise<PoolMetadata>`

`fetchPoolAddresses(): Promise<string[]>`

Position Management Methods

`createPosition(params: CreatePositionParams): Promise<{position: string}>`

`addLiquidityIntoPosition(params: AddLiquidityIntoPositionParams): Promise<void>`

`getUserPositions(params: UserPositionsParams): Promise<PositionInfo[]>`

`removeMultipleLiquidity(params: RemoveMultipleLiquidityParams): Promise<RemoveMultipleLiquidityResponse>`

Bin Array Management

`getBinArray(params: GetBinArrayParams): Promise<PublicKey>`

`getBinArrayInfo(params: GetBinsArrayInfoParams): Promise<{bins: any[], resultIndex: number}>`

`getBinsReserveInformation(params: GetBinsReserveParams): Promise<GetBinsReserveResponse[]>`

Pool Creation Methods

`createPairWithConfig(params: CreatePairWithConfigParams): Promise<PairCreationResult>`

Utility Methods

`getDexName(): string`

`getDexProgramId(): PublicKey`

`quote(params: QuickQuoteParams): Promise<GetTokenOutputResponse>`

Account Management Methods

`getPairVaultInfo(params: VaultInfoParams): Promise<PublicKey>`

`getUserVaultInfo(params: GetUserVaultInfoParams): Promise<PublicKey>`

Event Subscription Methods

`listenNewPoolAddress(postTxFunction: (address: string) => Promise<void>): void`

Advanced Calculation Methods (LBSwapService)

`calculateInOutAmount(params: GetTokenOutputParams): Promise<{amountIn: bigint, amountOut: bigint}>`

`calculateAmountOut(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>`

`calculateAmountIn(amount: bigint, bins: BinArrayRange, pairInfo: Pair, swapForY: boolean): Promise<bigint>`

Error Handling

Standard Error Types

Performance Characteristics

Method Performance

Network Configuration

Devnet Configuration

Mainnet Configuration

Quick Reference Table

Navigation

Reference Documentation

Getting Started (Tutorials)

Solve Problems (How-To Guides)

Understanding Concepts (Explanation)