> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raydium.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Các demo code LaunchLab

> TypeScript end-to-end: tạo một launch LaunchLab, mua và bán trên bonding curve, chuyển sang pool CPMM, và thu thập phí creator.

<Info>
  **Trang này được dịch tự động bằng AI. Phiên bản tiếng Anh là bản chính thức.**

  [Xem bản tiếng Anh →](/products/launchlab/code-demos)
</Info>

<Info>
  **Biểu ngữ phiên bản.**

  * SDK: `@raydium-io/raydium-sdk-v2@0.2.64-alpha`
  * Cluster: Solana `mainnet-beta`
  * Program ID: xem [`reference/program-addresses`](/vi/reference/program-addresses)
  * Xác minh lần cuối: **2026-09-09** với SDK `0.2.64-alpha` source, [`raydium-sdk-V2-demo/src/launchpad`](https://github.com/raydium-io/raydium-sdk-V2-demo/tree/master/src/launchpad), và source của chương trình `raydium-launch`

  Ghim phiên bản SDK trong `package.json` của bạn. Giao diện bonding-curve đã phát triển giữa các bản phát hành nhỏ.
</Info>

## Thiết lập

Các demo ở đây phản ánh các tệp trong [`raydium-sdk-V2-demo/src/launchpad`](https://github.com/raydium-io/raydium-sdk-V2-demo/tree/master/src/launchpad). Bootstrap tuân theo [`config.ts.template`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/config.ts.template) của repo demo:

```ts theme={null}
import { Connection, Keypair, clusterApiUrl, PublicKey } from "@solana/web3.js";
import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import BN from "bn.js";
import fs from "node:fs";

const connection = new Connection(process.env.RPC_URL ?? clusterApiUrl("mainnet-beta"));
const owner = Keypair.fromSecretKey(
  new Uint8Array(JSON.parse(fs.readFileSync(process.env.KEYPAIR!, "utf8"))),
);
const raydium = await Raydium.load({
  owner,
  connection,
  cluster: "mainnet",
  disableFeatureCheck: true,
  blockhashCommitment: "finalized",
});
export const txVersion = TxVersion.V0;
```

## Tạo một launch

Nguồn: [`src/launchpad/createMint.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/createMint.ts) (và [`createBonkMintApi.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/createBonkMintApi.ts) cho biến thể Bonk do API điều khiển)

Hầu hết các yếu tố kinh tế của launch **không phải** là các đối số — chúng đến từ `GlobalConfig` mà bạn liên kết thông qua `configId`, và SDK điền phần còn lại từ các tham số mặc định của API. Bạn truyền danh tính của mint, config để liên kết, và (tùy chọn) một lần mua đầu tiên:

```ts theme={null}
import {
  LAUNCHPAD_PROGRAM,
  DEVNET_PROGRAM_ID,
  LaunchpadConfig,
  getPdaLaunchpadConfigId,
} from "@raydium-io/raydium-sdk-v2";
import { Keypair, PublicKey } from "@solana/web3.js";
import { NATIVE_MINT } from "@solana/spl-token";

const programId = LAUNCHPAD_PROGRAM;          // devnet: DEVNET_PROGRAM_ID.LAUNCHPAD_PROGRAM

// Base mint là một keypair mà bạn tạo và ký.
const pair  = Keypair.generate();
const mintA = pair.publicKey;

// Liên kết một GlobalConfig: (quote mint, curve_type, index).
const configId = getPdaLaunchpadConfigId(programId, NATIVE_MINT, 0, 0).publicKey;
const configData = await raydium.connection.getAccountInfo(configId);
if (!configData) throw new Error("config not found");
const configInfo = LaunchpadConfig.decode(configData.data);
const mintBInfo = await raydium.token.getTokenInfo(configInfo.mintB);

const { execute, transactions, extInfo } = await raydium.launchpad.createLaunchpad({
  programId,
  mintA,
  decimals: 6,
  name:   "Example Token",
  symbol: "EXMPL",                 // phải là 10 ký tự hoặc ít hơn
  uri:    "https://example.com/metadata.json",   // phải không trống
  migrateType: "amm",              // "amm" | "cpmm"

  configId,
  configInfo,                      // tùy chọn; SDK sẽ đọc lại configId khi bị bỏ qua
  mintBDecimals: mintBInfo.decimals,
  mintBProgram:  new PublicKey(mintBInfo.programId),

  // Lần mua đầu tiên tùy chọn trong cùng một bundle.
  createOnly: true,                // true = chỉ tạo mint
  buyAmount:  new BN(1000),        // bị bỏ qua khi createOnly là true
  slippage:   new BN(100),         // 100 = 1%

  extraSigners: [pair],            // keypair base-mint phải ký
  txVersion: TxVersion.V0,

  // Các giá trị mặc định đến từ các giá trị mặc định API của config được liên kết; chỉ ghi đè nếu cần thiết:
  // supply:            new BN(1_000_000_000_000_000),
  // totalSellA:        new BN(793_100_000_000_000),
  // totalFundRaisingB: new BN(85_000_000_000),   // 85 SOL khi mintB là SOL
  // totalLockedAmount: new BN(0),
  // cliffPeriod:       new BN(0),                // giây
  // unlockPeriod:      new BN(0),                // giây
  // platformId:        new PublicKey("4Bu96XjU84XjPDSpveTVf6LYGCkfW5FK7SNkREWcEfV4"), // của Raydium, mặc định
});

// createLaunchpad trả về NHIỀU giao dịch - thực hiện chúng theo thứ tự.
const { txIds } = await execute({ sequentially: true });
console.log("Pool:", extInfo.address.poolId.toBase58());
console.log("Base mint:", mintA.toBase58());
console.log("Create txs:", txIds);
```

Ghi chú:

* **Không có** đối số `curveType`, `graduationFractionBps`, `initialK`, `quoteMint`, `openTime`, `fees` hoặc `postGraduationLpPolicy`. Hình dạng curve và quote mint là các thuộc tính của `GlobalConfig` mà bạn liên kết; tỷ lệ phí nằm trên `GlobalConfig` và `PlatformConfig`; xử lý LP tại graduation là một cài đặt `PlatformConfig`. Xem [`products/launchlab/instructions`](/vi/products/launchlab/instructions#initialize) để biết chính xác `InitializeV2` chấp nhận cái gì.
* `symbol` dài hơn 10 ký tự và `uri` trống đều bị từ chối phía client trước bất kỳ RPC nào.
* Truyền `transferFeeExtensionParams` chuyển builder sang `InitializeWithToken2022` và buộc `migrateType` thành `"cpmm"`.
* Builder trả về một mảng `transactions`; `createOnly: false` thêm giao dịch mua đầu tiên. Luôn `execute({ sequentially: true })` — mint phải tồn tại trước khi lần mua được thực hiện.

## Lấy trạng thái launch

Nguồn: [`src/launchpad/poolInfo.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/poolInfo.ts)

Không có `getLaunchById`. Pool id là một PDA của `(programId, mintA, mintB)`, và `getRpcPoolInfo` trả về `PoolState` được giải mã với `configInfo` được liên kết của nó:

```ts theme={null}
import { getPdaLaunchpadPoolId, Curve } from "@raydium-io/raydium-sdk-v2";

const poolId = getPdaLaunchpadPoolId(programId, mintA, NATIVE_MINT).publicKey;
const poolInfo = await raydium.launchpad.getRpcPoolInfo({ poolId });

console.log("status:", poolInfo.status);
console.log("base sold:", poolInfo.realA.toString(), "/", poolInfo.totalSellA.toString());
console.log("quote raised:", poolInfo.realB.toString(), "/", poolInfo.totalFundRaisingB.toString());

// Giá spot hiện tại trên curve.
const price = Curve.getPrice({
  poolInfo,
  curveType: poolInfo.configInfo.curveType,
  decimalA: poolInfo.mintDecimalsA,
  decimalB: poolInfo.mintDecimalsB,
});
console.log("price:", price.toString());
```

`getRpcPoolsInfo({ poolIdList })` là dạng batch và trả về một `poolInfoMap` được khóa bằng pool id — sử dụng nó cho các chế độ xem danh mục thay vì lặp. Nếu bạn muốn giải mã các tài khoản thô tự mình, `LaunchpadPool.decode` và `LaunchpadConfig.decode` được xuất.

## Mua — quote chính xác vào

Nguồn: [`src/launchpad/buy.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/buy.ts)

Trợ giúp quote ngoài chuỗi là **`Curve.buyExactIn`**, một phương thức tĩnh trên lớp `Curve` được xuất — không phải một phương thức trên `raydium.launchpad`. Builder giao dịch là **`buyToken`**. Cả hai đều cần tỷ lệ phí của nền tảng, nằm trên một tài khoản `PlatformConfig` riêng biệt:

```ts theme={null}
import { Curve, PlatformConfig, toTransferFeeConfig } from "@raydium-io/raydium-sdk-v2";

const inAmount = new BN(1).mul(new BN(10).pow(new BN(9)));   // 1 SOL
const slippage = new BN(100);                                 // 100 = 1%

const poolInfo = await raydium.launchpad.getRpcPoolInfo({ poolId });
const platformData = await raydium.connection.getAccountInfo(poolInfo.platformId);
const platformInfo = PlatformConfig.decode(platformData!.data);

const mintInfo  = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(poolInfo.mintB);
const epochInfo = await raydium.connection.getEpochInfo();

// Xem trước ngoài chuỗi — phản ánh toán học curve trên chuỗi.
const res = Curve.buyExactIn({
  poolInfo,
  amountB: inAmount,
  protocolFeeRate: poolInfo.configInfo.tradeFeeRate,
  platformFeeRate: platformInfo.feeRate,
  creatorFeeRate:  platformInfo.creatorFeeRate,
  curveType:       poolInfo.configInfo.curveType,
  shareFeeRate:    new BN(0),
  transferFeeConfigA: mintInfo.extensions.feeConfig  ? toTransferFeeConfig(mintInfo,  epochInfo.epoch) : undefined,
  transferFeeConfigB: mintBInfo.extensions.feeConfig ? toTransferFeeConfig(mintBInfo, epochInfo.epoch) : undefined,
  slot: await raydium.connection.getSlot(),
});
console.log("expected out:", res.amountA.amount.sub(res.amountA.fee ?? new BN(0)).toString());

const { execute, extInfo } = await raydium.launchpad.buyToken({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  transferFeeConfigB: toTransferFeeConfig(mintBInfo, epochInfo.epoch),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,
  buyAmount:       inAmount,
  slippage,                       // BN tính bằng bps; SDK lấy minMintAAmount từ nó
  txVersion: TxVersion.V0,
});

console.log("expected receive amount:", extInfo.decimalOutAmount.toString());
const { txId } = await execute({ sendAndConfirm: true });
console.log("Buy tx:", txId);
```

Bạn có thể truyền `minMintAAmount` một cách rõ ràng thay vì `slippage`; bỏ qua cả hai và SDK sẽ tính toán giới hạn từ dữ liệu RPC trực tiếp. `shareFeeRate` không được vượt quá `poolInfo.configInfo.maxShareFeeRate`, và nó chỉ áp dụng khi bạn cũng truyền một `shareFeeReceiver`.

## Mua — base chính xác ra

Builder là **`buyTokenExactOut`**, và các đối số số lượng là `outAmount` (base bạn muốn) và `maxBuyAmount` (quote bạn sẽ chi tối đa). `Curve.buyExactOut({ poolInfo, amountA, ... })` là xem trước ngoài chuỗi phù hợp.

```ts theme={null}
const { execute, extInfo } = await raydium.launchpad.buyTokenExactOut({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,

  outAmount:    new BN(1_000_000).mul(new BN(10).pow(new BN(6))),  // 1M base
  maxBuyAmount: new BN(2).mul(new BN(10).pow(new BN(9))),          // giới hạn ở 2 SOL
  slippage:     new BN(100),

  txVersion: TxVersion.V0,
});

console.log("out:", extInfo.outAmount.toString(), "max spent:", extInfo.maxSpentAmount.toString());
await execute({ sendAndConfirm: true });
```

Hữu ích cho các UI "mua chính xác X token". Builder từ chối `outAmount` bằng không phía client, và chương trình sẽ hoàn nguyên nếu curve đã di chuyển đủ để yêu cầu quote vượt quá `maxBuyAmount`.

## Bán

Nguồn: [`src/launchpad/sell.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/sell.ts)

Builder là **`sellToken`** (`sellTokenExactOut` cho biến thể exact-quote-out), với `sellAmount` và một `minAmountB` tùy chọn. `Curve.sellExactIn({ poolInfo, amountA, ... })` xem trước nó.

```ts theme={null}
const inAmount = new BN(500_000).mul(new BN(10).pow(new BN(6)));  // 0.5M base

const res = Curve.sellExactIn({
  poolInfo,
  amountA: inAmount,
  protocolFeeRate: poolInfo.configInfo.tradeFeeRate,
  platformFeeRate: platformInfo.feeRate,
  creatorFeeRate:  platformInfo.creatorFeeRate,
  curveType:       poolInfo.configInfo.curveType,
  shareFeeRate:    new BN(0),
  transferFeeConfigA: mintInfo.extensions.feeConfig  ? toTransferFeeConfig(mintInfo,  epochInfo.epoch) : undefined,
  transferFeeConfigB: mintBInfo.extensions.feeConfig ? toTransferFeeConfig(mintBInfo, epochInfo.epoch) : undefined,
  slot: await raydium.connection.getSlot(),
});
console.log("expected quote out:", res.amountB.toString());

const { execute } = await raydium.launchpad.sellToken({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,
  sellAmount:      inAmount,
  slippage:        new BN(100),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
```

Đường bán của curve đối xứng với đường mua: giảm `real_a` bằng `sellAmount` trả về `quote_out` bằng diện tích tích phân dưới curve giữa `real_a − sellAmount` và `real_a`, trừ phí bán. `sellAmount` phải lớn hơn không — builder từ chối không trước bất kỳ RPC nào.

## Graduation

<Warning>
  **Graduation không phải là điều mà một integrator có thể kích hoạt.** Không có `raydium.launchpad.graduate`, không có cờ `autoGraduate` trên các builder mua, và không có trường `willGraduate` trên giá trị trả về của chúng. Trên chuỗi, graduation là `MigrateToCpswap` (hoặc `MigrateToAmm` kế thừa), và cả hai hướng dẫn đều hạn chế người ký của chúng thành một ví được ghi lại trên `GlobalConfig` liên kết — `migrate_to_cpswap_wallet` và `migrate_to_amm_wallet` tương ứng. Một cuộc gọi từ bất kỳ người ký nào khác sẽ thất bại với `InvalidOwner`. Nó **không** được phép, và không có bot MEV nào có thể chạy đua với nó.
</Warning>

Những ví đó được vận hành bởi crank graduation của Raydium, vì vậy trong thực tế migration sẽ được thực hiện trong vài giây sau khi ngưỡng bị vượt qua bất kể ai thực hiện lần mua cuối cùng. Từ phía integrator, điều duy nhất cần làm là coi sự chuyển đổi trạng thái như một sự kiện nhanh: poll `getRpcPoolInfo` (hoặc đăng ký qua gRPC, bên dưới) và chuyển UI của bạn từ curve sang pool CPMM kết quả khi `status` thay đổi.

Xem [`products/launchlab/instructions`](/vi/products/launchlab/instructions#migratetoamm-/-migratetocpswap) để biết danh sách tài khoản, phí migration, và cách LP được chia tại graduation.

## Thu thập phí creator

Nguồn: [`src/launchpad/claimCreatorFee.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/claimCreatorFee.ts) (mint đơn) và [`collectAllCreatorFees.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/launchpad/collectAllCreatorFees.ts) (batch)

Phương thức là **`claimCreatorFee`** (và `claimMultipleCreatorFee` cho dạng batch). Nó được khóa bằng **quote mint**, không phải bằng một launch — một cuộc gọi quét phí creator tích lũy của người ký trong mint đó trên tất cả các launch của họ:

```ts theme={null}
import { NATIVE_MINT } from "@solana/spl-token";

const { execute } = await raydium.launchpad.claimCreatorFee({
  programId,
  mintB: NATIVE_MINT,          // quote mint để claim
  // mintBProgram: TOKEN_PROGRAM_ID,   // hoặc TOKEN_2022_PROGRAM_ID
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
```

Chuyển bộ đếm phí creator tích lũy sang ATA của creator trên quote mint. Có thể gọi trước hoặc sau graduation; sử dụng nó định kỳ thay vì chờ một số dư khổng lồ tích lũy. Các nhà khai thác nền tảng có các builder song song `claimPlatformFee` / `claimAllPlatformFee` / `claimVaultPlatformFee`.

## Theo dõi một launch qua vòng đời của nó

Kết hợp lại, một script giám sát có thể trông như thế này:

```ts theme={null}
async function watch(poolId: PublicKey) {
  const startStatus = (await raydium.launchpad.getRpcPoolInfo({ poolId })).status;

  while (true) {
    const p = await raydium.launchpad.getRpcPoolInfo({ poolId });
    const progress = Number(p.realB.toString()) / Number(p.totalFundRaisingB.toString());

    console.log(`status=${p.status}`, `progress=${(progress * 100).toFixed(2)}%`);

    if (p.status !== startStatus) {
      console.log("status changed - the launch has migrated; switch to the pool page");
      break;
    }
    await new Promise((r) => setTimeout(r, 10_000));
  }
}
```

Poll `getRpcPoolInfo` trên bộ hẹn giờ 10 giây là tốt cho một launch duy nhất. Đối với một indexer, hãy sử dụng đăng ký gRPC bên dưới thay thế — `getRpcPoolsInfo({ poolIdList })` batch, nhưng poll hàng trăm pool vẫn tiêu tốn tín dụng RPC mà không có lợi ích.

## Theo dõi configs và pools qua gRPC

Nguồn: [`src/grpc/launchpadPoolInfo.ts`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/grpc/launchpadPoolInfo.ts)

Đăng ký chương trình LaunchLab qua Yellowstone gRPC và ghi nhật ký mọi cập nhật `GlobalConfig` và `PoolState` với chương trình token của mỗi mint. Hai bộ lọc `datasize` trên một đăng ký `accounts` tách hai loại tài khoản, vì vậy một luồng duy nhất bao gồm cả hai.

Demo là tài liệu tham khảo chính xác ngắn nhất để phân loại mint của một launch, điều mà [phiên bản quote-mint Token-2022](/vi/reference/changelog/2026-08-24-launchlab-token2022-quote-mint) làm cần thiết:

* **Pools** được phân loại trực tiếp từ `PoolState.token_program_flag`, giải mã bit0 cho base mint và bit1 cho quote mint mà không cần lấy mint nào cả. Kiểm tra toàn bộ byte so với `0` — điều này đã đủ trong khi quote mint chỉ là legacy — sẽ đọc sai một base mint legacy là Token-2022 bất cứ khi nào quote mint là Token-2022.
* **Configs** không thể được phân loại theo cách đó: một `GlobalConfig` lưu trữ địa chỉ quote mint của nó và không có cờ chương trình, vì vậy demo sẽ đọc chủ sở hữu tài khoản mint một lần và lưu vào bộ nhớ cache cho mỗi mint.

Nó cũng kiểm tra chéo hai cái với nhau, điều này là một khẳng định hữu ích để giữ trong indexer của riêng bạn. Lưu ý rằng `create` so với `update` được suy ra từ bộ nhớ cache của demo, được gieo hạt khi khởi động từ `getProgramAccounts`; với việc gieo hạt đó bị vô hiệu hóa, hãy đọc "create" là "lần đầu tiên được nhìn thấy trên luồng này".

Truy cập gRPC không phải là một phần của bề mặt RPC công khai — xem [`src/grpc/README.md`](https://github.com/raydium-io/raydium-sdk-V2-demo/blob/master/src/grpc/README.md) của repo demo.

## Rust CPI

Gọi LaunchLab từ chương trình Anchor của riêng bạn là hiếm (hầu hết các tích hợp launch chỉ là phía TS). Nếu bạn làm:

* Crate là **`raydium-launchpad`** (tên lib `raydium_launchpad`), phiên bản `0.2.0`, và nó có tiếp xúc với tính năng `cpi`. **Không có** `raydium_launchlab`.
* Nó **không được xuất bản trên crates.io** — phụ thuộc vào nó bằng git revision, cách tương tự như các crate chương trình Raydium khác.
* Các điểm vào CPI được đặt tên theo các hướng dẫn trên chuỗi, không phải theo các phương thức TypeScript của SDK: `buy_exact_in`, `buy_exact_out`, `sell_exact_in`, `sell_exact_out`, `claim_creator_fee`, `create_vesting_account`, `claim_vested_token`. `migrate_to_amm` / `migrate_to_cpswap` được gated người ký cho các ví migration `GlobalConfig` và không thể gọi từ một chương trình integrator.

Xem [`sdk-api/rust-cpi`](/vi/sdk-api/rust-cpi) để biết các quy tắc ghim crate — đặc biệt là phân tách phiên bản Anchor, quyết định xem một crate có thể CPI vào cả LaunchLab và CLMM hay không.

## Những cạm bẫy

* **Nhầm lẫn tên hướng dẫn trên chuỗi với tên phương thức SDK.** Chương trình có `buy_exact_in` / `sell_exact_in`; SDK có `buyToken` / `sellToken`. `buyExactIn` và `sellExactIn` chỉ tồn tại dưới dạng **phương thức tĩnh trên `Curve`**, và chúng tính toán một quote — chúng không xây dựng một giao dịch.
* **Quên `extraSigners`.** `createLaunchpad` tạo base mint từ một keypair mà bạn tạo, vì vậy keypair đó phải ký. Bỏ qua `extraSigners: [pair]` và giao dịch sẽ thất bại xác minh chữ ký.
* **Không chọn quote mint.** Bạn không truyền một. Quote mint là một thuộc tính của `GlobalConfig` mà bạn liên kết thông qua `configId` — `getPdaLaunchpadConfigId(programId, quoteMint, curveType, index)`. Để launch chống lại một quote mint khác, liên kết một config khác; `raydium.api.fetchLaunchConfigs()` liệt kê các config có sẵn với các tham số mặc định của chúng.
* **Kích thước metadata.** Các chuỗi `uri` dài đẩy Metaplex CPI vượt quá ngân sách. Giữ `uri` dưới \~200 ký tự — hầu hết metadata JSON được lưu trữ trên CDN phù hợp dễ dàng. `symbol` bị giới hạn cứng ở 10 ký tự.
* **Coi graduation như một cuộc đua mà bạn có thể tham gia.** Nó không phải — xem cảnh báo ở trên. UI của bạn vẫn nên coi các chuyển đổi `status` như các sự kiện nhanh, vì crank của Raydium sẽ thực hiện migration trong vài giây sau khi ngưỡng bị vượt qua.

## Tiếp theo đi đâu

* [`products/launchlab/bonding-curve`](/vi/products/launchlab/bonding-curve) — toán học curve.
* [`products/cpmm/code-demos`](/vi/products/cpmm/code-demos) — điều cần làm với pool kết quả.
* [`user-flows/launch-token-launchlab`](/vi/user-flows/launch-token-launchlab) — hướng dẫn launch-a-token end-to-end, bao gồm các bước ngoài chuỗi.

Nguồn:

* [Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2)
* Nguồn chương trình Raydium LaunchLab


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.