DLMM Pro TS SDK Getting Started

Prerequisites

Installation

npm install @meteora-ag/dlmm-pro-sdk @solana/web3.js @solana/spl-token bn.js

pnpm add @meteora-ag/dlmm-pro-sdk @solana/web3.js @solana/spl-token bn.js

yarn add @meteora-ag/dlmm-pro-sdk @solana/web3.js @solana/spl-token bn.js

TypeScript Configuration

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "Bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "types": ["node"],
    "noEmit": true
  }
}

• module ESNext with moduleResolution Bundler is the configuration the examples were checked with. module and moduleResolution both set to NodeNext also type-checks the .mts scripts.
• Top-level await compiled with the target set to ES2022 and to ES2020.
• skipLibCheck is needed. Without it tsc reports an error inside the declarations of @solana/buffer-layout, a dependency of web3.js, that has nothing to do with your code.
• The scripts type-check without esModuleInterop, but the SDK’s own configuration sets it and import BN from "bn.js" is written with it in mind.
• process.env needs @types/node installed and "types": ["node"] in the tsconfig.
• The scripts use top-level await, so they must run as ES modules. A .ts file in a CommonJS package fails under tsx with Top-level await is currently not supported with the "cjs" output format. Rename it to .mts or set "type": "module" in package.json.

CommonJS and ESM

// ES module: a .mjs file, or any file in a package with "type": "module"
import { DlmmProClient } from "@meteora-ag/dlmm-pro-sdk";

// CommonJS: a .cjs file, or any file in a package without "type": "module"
const { DlmmProClient } = require("@meteora-ag/dlmm-pro-sdk");

• With module set to CommonJS and moduleResolution set to Bundler, a .cts file can import the package normally.
• With module and moduleResolution set to Node16, a CommonJS TypeScript file that imports the package fails with TS1479. The package declares "type": "module" and has one set of type declarations, which TypeScript reads as an ES module, so it refuses the require call it would emit. Import the package from an .mts file instead, switch to NodeNext or Bundler, or use a dynamic import(), which type-checks under Node16 (with the same types setting as above, because it reads process.env) and runs.

// A .cts file compiled with module and moduleResolution set to Node16
import { Connection } from "@solana/web3.js";

async function main() {
  const { DlmmProClient } = await import("@meteora-ag/dlmm-pro-sdk");
  const client = new DlmmProClient(new Connection(process.env.RPC_URL!, "confirmed"));
  console.log(typeof client.pool.swap);
}
main();

Create a Client

import { Connection } from "@solana/web3.js";
import { DlmmProClient } from "@meteora-ag/dlmm-pro-sdk";

const connection = new Connection(process.env.RPC_URL!, "confirmed");
const client = new DlmmProClient(connection);

Fund a Devnet Wallet and Find a Pool

import { Keypair } from "@solana/web3.js";

// A throwaway devnet wallet. Never put funds you care about in a key printed to a terminal.
const wallet = Keypair.generate();
console.log("address", wallet.publicKey.toBase58());
console.log(
  "export WALLET_SECRET_KEY='" + JSON.stringify([...wallet.secretKey]) + "'",
);

import { Connection } from "@solana/web3.js";
import { DLMM_PRO_PROGRAM_ID, DlmmProClient } from "@meteora-ag/dlmm-pro-sdk";

const connection = new Connection(process.env.RPC_URL!, "confirmed");
const client = new DlmmProClient(connection);

// Every Pool account, found by its discriminator (f19a6d0411b16dbc in hex,
// hQrXeCntzbV in base58). The empty data slice returns only the addresses.
const accounts = await connection.getProgramAccounts(DLMM_PRO_PROGRAM_ID, {
  filters: [{ memcmp: { offset: 0, bytes: "hQrXeCntzbV" } }],
  dataSlice: { offset: 0, length: 0 },
});
console.log(accounts.length, "pools");

let shown = 0;
for (const { pubkey } of accounts) {
  const pool = await client.state.fetchPool(pubkey);
  // poolStatus 0 means swaps and deposits are on. Skip pools with no active liquidity.
  if (pool.poolStatus !== 0 || pool.liquidity.isZero()) continue;
  console.log(
    pubkey.toBase58(),
    `X ${pool.tokenXMint.toBase58()}`,
    `Y ${pool.tokenYMint.toBase58()}`,
    `tick ${pool.tickCurrentId}`,
    `spacing ${pool.tickSpacing}`,
    `extensions ${pool.extensions}`,
  );
  if (++shown === 10) break;
}

• Devnet tokens are test tokens. The script sells one whole token X, so you need a balance of the pool’s token X, or pick a pool whose token X is wrapped SOL: the builder wraps the SOL this script sells. The second half of the wrapped SOL example shows a purchase paid in SOL.
• Liquidity is thin on many test pools. When one whole token X is more than the pool can take, the script stops with Not enough liquidity for this input. Lower inputAmount.
• extensions is a bitmask: 1 is LiquidityMining and 2 is ActivationAccess. A pool with activation rules can reject swaps until its activation point with InvalidActivationAccess.

Quote and Swap

import {
  Connection,
  Keypair,
  PublicKey,
  sendAndConfirmTransaction,
} from "@solana/web3.js";
import { getMint } from "@solana/spl-token";
import BN from "bn.js";
import {
  DlmmProClient,
  getTokenProgram,
  tickUiPrice,
} from "@meteora-ag/dlmm-pro-sdk";

const connection = new Connection(process.env.RPC_URL!, "confirmed");
const client = new DlmmProClient(connection);

const pool = new PublicKey(process.env.POOL_ADDRESS!);
const user = Keypair.fromSecretKey(
  Uint8Array.from(JSON.parse(process.env.WALLET_SECRET_KEY!)),
);

// Read the pool
const poolState = await client.state.fetchPool(pool);
const [mintX, mintY] = await Promise.all([
  getMint(
    connection,
    poolState.tokenXMint,
    "confirmed",
    getTokenProgram(poolState.tokenXFlag),
  ),
  getMint(
    connection,
    poolState.tokenYMint,
    "confirmed",
    getTokenProgram(poolState.tokenYFlag),
  ),
]);
const price = tickUiPrice(
  poolState.tickCurrentId,
  mintX.decimals,
  mintY.decimals,
);
console.log(`tick ${poolState.tickCurrentId}, ~${price.toFixed(6)} Y per X`);

// Quote 1 token X for token Y
const inputAmount = new BN(10).pow(new BN(mintX.decimals));
const { quote, tickArrays, tickArrayBitmapExtension } =
  await client.pool.quoteExactIn({
    pool,
    inputAmount,
    swapForY: true,
    swapper: user.publicKey,
  });
if (!quote.amountLeft.isZero()) {
  throw new Error("Not enough liquidity for this input");
}

// Swap, accepting up to 0.5% less than the quote
const { tx } = await client.pool.swap({
  pool,
  tokenXMint: poolState.tokenXMint,
  tokenYMint: poolState.tokenYMint,
  user: user.publicKey,
  swapForY: true,
  tickArrays,
  tickArrayBitmapExtension,
  parameters: {
    inputAmount,
    minimumOutputAmount: quote.transferFeeExcludedOutAmount
      .muln(9_950)
      .divn(10_000),
  },
});
const signature = await sendAndConfirmTransaction(connection, tx, [user]);
console.log("swap", signature);

• quoteExactIn loads the tick arrays the swap will cross and returns them; pass them to swap unchanged. If quote.amountLeft is not zero, the loaded arrays ran out of liquidity and the swap would fail. Raise maxTickArrays or reduce the input.
• The quote reads the fee at the current time. Scheduled and dynamic fees can change before the transaction lands, which is one more reason to leave room in minimumOutputAmount.
• transferFeeExcludedOutAmount is what the wallet receives after any Token 2022 transfer fee on the output mint, and it is what minimumOutputAmount is compared with.

What the Script Does

1. Read the pool. fetchPool returns the decoded Pool account: the two mints, their token program flags (0 is the SPL Token program and 1 is Token 2022), the current tick tickCurrentId, the tick spacing, the fee settings and the pool’s status. getTokenProgram turns a flag into the program ID that getMint needs, and getMint gives the decimals. tickUiPrice converts the tick into a UI price, 1.0001 ** tick scaled by 10 ** (decimalsX - decimalsY), so the log line prints token Y per token X. The pool’s exact price lies between this tick and the next, so the printed price is close but not exact.
2. Quote. inputAmount is one whole token X in atoms. client.pool.quoteExactIn reads the pool, its tick arrays, the mints for transfer fees and the clock, and runs the program’s swap math. It returns quote (the fields below), tickArrays (the addresses of the tick arrays the swap crosses, in the order the program wants them) and tickArrayBitmapExtension (an address when the swap needs it, otherwise null). swapper only matters before a pool with activation rules opens, when a whitelisted wallet may swap early. By default the quote loads the first 3 tick arrays with liquidity, and maxTickArrays raises that.
3. Check amountLeft. A non-zero value means the loaded tick arrays ran out of liquidity before the input was used up. The swap would fail with NotConsumingFullAmountIn, so the script stops.
4. Swap. client.pool.swap builds the transaction from the accounts the quote chose. minimumOutputAmount is the quoted output less 0.5%: muln(9_950).divn(10_000) multiplies by 9,950 and divides by 10,000, rounding down. The result is an unsigned Transaction. sendAndConfirmTransaction adds a recent blockhash, signs with the wallet, sends and waits for confirmation at the connection’s commitment. It returns the signature, and the script prints it.

Quote Result Fields

Choosing Slippage

import BN from "bn.js";

// Smallest output to accept: the quoted output less a tolerance in basis points
function minimumOutput(quoted: BN, slippageBps: number): BN {
  return quoted.muln(10_000 - slippageBps).divn(10_000);
}

console.log(minimumOutput(new BN(1_000_000), 50).toString()); // 0.5% below the quote

• Other swaps move the price and use up liquidity in your direction.
• The dynamic fee rises with volatility, so a pool that has just moved charges more.
• A time-based fee schedule only falls, which helps you.
• A Token 2022 transfer fee can change at an epoch boundary.

How Builders Work

• Token accounts. User token accounts default to the wallet’s associated token accounts. A missing one is created in the same transaction, paid by the fee payer.
• Wrapped SOL. When a wallet pays or receives SOL through its default token account, the builder wraps or unwraps it in the same transaction. An account you pass explicitly is used as is.
• Accounts the program needs. swap takes its tick arrays from quoteExactIn, position builders derive theirs from the tickRanges you pass, and limit order builders resolve their own. The bitmap extension and Token 2022 transfer hook accounts are resolved when you leave them out.
• Compute budget. Builders add no compute budget instructions. Opening or expanding a position with many ranges can need more than the default 200,000 compute units, so add ComputeBudgetProgram.setComputeUnitLimit to those transactions, and setComputeUnitPrice when you want a priority fee.
• Operator and admin instructions are not wrapped. Build them with client.program.methods.<instruction>(...) if you need them.

Errors

import { PoolError, PoolErrorCode } from "@meteora-ag/dlmm-pro-sdk";

try {
  await client.pool.quoteExactIn({ pool, inputAmount, swapForY: true });
} catch (error) {
  if (
    error instanceof PoolError &&
    error.code === PoolErrorCode.LiquidityIsZero
  ) {
    console.log("No liquidity in that direction");
  } else {
    throw error;
  }
}

// A failed transaction reports InstructionError: [0, { Custom: 6020 }]
PoolErrorCode[6020]; // "NotConsumingFullAmountIn"

Troubleshooting

Next Steps