Démos de code LaunchLab

TypeScript de bout en bout : créer un lancement LaunchLab, acheter et vendre sur la courbe de liaison, diplômer dans un pool CPMM et collecter les frais du créateur.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.

Voir la version anglaise →

Banneau de version.

• SDK : @raydium-io/raydium-sdk-v2@0.2.42-alpha
• Cluster : Solana mainnet-beta
• ID du programme : voir reference/program-addresses
• Dernière vérification : 2026-04

Épinglez la version du SDK dans votre package.json. L’interface de la courbe de liaison a évolué entre les versions mineures.

​

Configuration

Les démos ici reflètent les fichiers dans raydium-sdk-V2-demo/src/launchpad. L’amorçage suit le config.ts.template du dépôt de démo :

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;

​

Créer un lancement

Source : src/launchpad/createMint.ts (et createBonkMintApi.ts pour la variante Bonk pilotée par API)

import { NATIVE_MINT } from "@solana/spl-token";

const { execute, extInfo } = await raydium.launchpad.createLaunchpad({
  programId: /* ID du programme LaunchLab depuis reference/program-addresses */,
  // Métadonnées du token pour le nouveau mint de base :
  name:   "Example Token",
  symbol: "EXMPL",
  uri:    "https://example.com/metadata.json",
  decimals: 6,

  // Paramètres de la courbe :
  curveType: 0,                                      // 0 = quadratique
  supply:    new BN(1_000_000_000).mul(new BN(10).pow(new BN(6))), // 1B base (6 déc)
  graduationFractionBps: 8000,                       // 80% → diplôme
  initialK:  new BN("40"),                           // paramètre de forme de courbe

  // Côté devis :
  quoteMint: NATIVE_MINT,                            // WSOL
  openTime:  new BN(Math.floor(Date.now() / 1000) + 60),  // ouvre dans 1min

  // Politique de frais :
  fees: {
    buyNumerator:   new BN(100),                     // 1,00%
    buyDenominator: new BN(10_000),
    sellNumerator:  new BN(100),
    sellDenominator: new BN(10_000),
    lpShare:         new BN(60),
    creatorShare:    new BN(20),
    protocolShare:   new BN(20),
    totalShare:      new BN(100),
  },

  postGraduationLpPolicy: "burn",                    // "burn" | "lock" | "toCreator"

  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Launch:", extInfo.launchState.toBase58());
console.log("Base mint:", extInfo.baseMint.toBase58());
console.log("Create tx:", txId);

Notes :

• initialK est le facteur d’échelle pour la courbe quadratique. Réglez-le pour cibler un prix CPMM d’ouverture spécifique à la diplomation. Voir products/launchlab/bonding-curve pour la dérivation.
• Le SDK gère la création du mint de base, du PDA de métadonnées et des deux coffres-forts dans une seule transaction. Il peut dépasser 1232 octets si l’URI des métadonnées est long ; dans ce cas, le SDK se divise en deux transactions.
• Après Initialize, le lancement n’est pas négociable jusqu’à openTime. Définissez openTime une ou deux minutes à l’avance pour donner moins de chances aux front-runners de saisir le premier achat.

​

Récupérer l’état du lancement

const launchId = new PublicKey("<LAUNCH_STATE>");

const launch = await raydium.launchpad.getLaunchById({ launchId });
console.log("Status:", ["Active","Graduated","Cancelled"][launch.status]);
console.log("Base sold:", launch.baseSold.toString(),
            "/", launch.baseSupplyMax.toString());
console.log("Quote collected:", launch.quoteReserveReal.toString(),
            "target:", launch.quoteReserveTarget.toString());
if (launch.status === 1) {
  console.log("Post-graduation CPMM pool:", launch.cpmmPoolState.toBase58());
}

getLaunchById retourne le LaunchState décodé plus la fraction « progression vers la diplomation » calculée en tant que Decimal.

​

Acheter — devis exact en entrée

Source : src/launchpad/buy.ts

const quoteIn        = new BN(1).mul(new BN(10).pow(new BN(9)));  // 1 SOL
const minimumBaseOut = new BN(0);  // accepter n'importe quel ; resserrer pour la production

// Prévisualisez le devis hors chaîne pour que votre interface utilisateur puisse afficher la base_out attendue :
const preview = raydium.launchpad.computeBuyBase({
  launchState: launch,
  quoteIn,
});
console.log("Expected base_out:", preview.baseOut.toString(),
            "price impact:", preview.priceImpact.toString());

const { execute } = await raydium.launchpad.buyExactIn({
  launchInfo: launch,
  quoteIn,
  minimumBaseOut,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Buy tx:", txId);

computeBuyBase reflète le solveur Newton sur chaîne (courbe quadratique) ou l’inverse CPMM de forme fermée (curve_type 1). Utilisez-le pour remplir le champ « Vous recevez » de l’interface utilisateur.

​

Acheter — base exacte en sortie

const baseOut         = new BN(1_000_000).mul(new BN(10).pow(new BN(6)));  // 1M base
const maximumQuoteIn  = new BN(2).mul(new BN(10).pow(new BN(9)));          // plafonner à 2 SOL

const { execute } = await raydium.launchpad.buyExactOut({
  launchInfo: launch,
  baseOut,
  maximumQuoteIn,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Utile pour les interfaces « acheter exactement X tokens ». Rejette avec ExceededSlippage si la courbe a bougé suffisamment pour que l’exigence de devis dépasse maintenant maximumQuoteIn.

​

Vendre

Source : src/launchpad/sell.ts

const baseIn           = new BN(500_000).mul(new BN(10).pow(new BN(6)));  // 0,5M base
const minimumQuoteOut  = new BN(0);

const { execute } = await raydium.launchpad.sellExactIn({
  launchInfo: launch,
  baseIn,
  minimumQuoteOut,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Le chemin de vente de la courbe est symétrique au chemin d’achat : réduire base_sold par baseIn retourne quote_out égal à la zone intégrée sous la courbe entre base_sold − baseIn et base_sold, moins les frais de vente.

​

Diplôme automatique lors de l’achat de franchissement de seuil

Le SDK enchaîne une instruction Graduate dans la transaction buy* lorsqu’il détecte que l’état post-achat franchira le seuil :

const { execute, willGraduate } = await raydium.launchpad.buyExactIn({
  launchInfo: launch,
  quoteIn: new BN(100).mul(new BN(10).pow(new BN(9))),    // grand achat
  minimumBaseOut: new BN(0),
  txVersion: TxVersion.V0,
  autoGraduate: true,                                      // par défaut
});

if (willGraduate) {
  console.log("This buy will trigger graduation.");
}

const { txId } = await execute({ sendAndConfirm: true });

Parce que Graduate est sans permission, n’importe qui (y compris un bot MEV) peut faire la course pour atterrir le premier Graduate après le franchissement du seuil — généralement quelques secondes plus tard, pas des minutes. Le premier arrivant paie simplement le loyer des comptes du pool CPMM ; ils ne reçoivent aucun autre avantage.

​

Graduate manuel

Si autoGraduate était désactivé ou si la transaction de franchissement de seuil a échoué, vous pouvez déclencher la diplomation séparément :

const { execute } = await raydium.launchpad.graduate({
  launchInfo: launch,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Revient avec NotAtThreshold si quote_reserve_real < quote_reserve_target au moment de la soumission. Sûr pour les tentatives — une deuxième tentative Graduate après succès revient avec NotActive.

​

Collecter les frais du créateur

Source : src/launchpad/claimCreatorFee.ts (mint unique) et collectAllCreatorFees.ts (par lot)

const { execute } = await raydium.launchpad.collectCreatorFees({
  launchInfo: launch,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Transfère le montant du compteur de frais du créateur accumulé vers l’ATA du créateur sur le mint de devis. Appelable avant ou après la diplomation ; utilisez-le périodiquement plutôt que d’attendre qu’un énorme solde s’accumule.

​

Suivre un lancement tout au long de son cycle de vie

En mettant tout ensemble, un script de surveillance pourrait ressembler à :

async function watch(launchId: PublicKey) {
  while (true) {
    const launch = await raydium.launchpad.getLaunchById({ launchId });
    const progress =
      Number(launch.quoteReserveReal) /
      Number(launch.quoteReserveTarget);

    console.log(
      `status=${["Active","Graduated","Cancelled"][launch.status]}`,
      `progress=${(progress * 100).toFixed(2)}%`,
      `num_buys=${launch.stateData.numBuys}`,
    );

    if (launch.status === 1) {
      console.log("Graduated to CPMM pool:", launch.cpmmPoolState.toBase58());
      break;
    }
    await new Promise(r => setTimeout(r, 10_000));
  }
}

​

Surveiller les configurations et les pools sur gRPC

Source : src/grpc/launchpadPoolInfo.ts

S’abonne au programme LaunchLab sur Yellowstone gRPC et enregistre chaque mise à jour GlobalConfig et PoolState avec le programme de token de chaque mint. Deux filtres datasize sur un abonnement accounts séparent les deux types de comptes, donc un seul flux couvre les deux.

La démo est la référence la plus courte et correcte pour classer les mints d’un lancement, ce que la version de quote-mint Token-2022 rend nécessaire :

• Les pools sont classés directement à partir de PoolState.token_program_flag, en décodant le bit0 pour le mint de base et le bit1 pour le mint de devis sans aucune récupération de mint. Tester l’octet entier contre 0 — ce qui était suffisant alors que les mints de devis étaient hérités uniquement — mésinterprète un mint de base hérité comme Token-2022 chaque fois que le mint de devis est Token-2022.
• Les configurations ne peuvent pas être classées de cette façon : un GlobalConfig stocke l’adresse du mint de devis et aucun drapeau de programme, donc la démo lit le propriétaire du compte mint une fois et le met en cache par mint.

Il effectue également une vérification croisée des deux l’un contre l’autre, ce qui est une assertion utile à conserver dans votre propre indexeur. Notez que « créer » par rapport à « mettre à jour » est déduit des caches propres de la démo, amorcés au démarrage à partir de getProgramAccounts ; avec cet amorçage désactivé, lisez « créer » comme « d’abord vu sur ce flux ».

L’accès gRPC ne fait pas partie de la surface RPC publique — voir le src/grpc/README.md du dépôt de démo.

​

CPI Rust

Appeler LaunchLab à partir de votre propre programme Anchor est rare (la plupart des intégrations de lancement sont côté TS uniquement). Si vous le faites, le programme expédie une caisse Anchor raydium_launchlab avec cpi::accounts::Buy, cpi::accounts::Sell, etc. — le motif reflète les exemples CPI CPMM / CLMM. Voir sdk-api/rust-cpi pour un modèle généralisé une fois ce site rempli.

​

Pièges

• Arithmétique de répartition des frais hors d’un. Si total_share n’est pas exactement lp_share + creator_share + protocol_share, Initialize revient avec InvalidFeeShares. Définissez totalShare égal à la somme.
• Utiliser un mint de devis non autorisé. launch_config.allowed_quote_mints est une liste fixe ; passer n’importe quel autre mint revient. Vérifiez d’abord avec raydium.launchpad.getConfig().
• Taille des métadonnées. Les longues chaînes uri poussent le CPI Metaplex au-delà du budget. Gardez uri sous ~200 caractères — la plupart des métadonnées JSON hébergées sur CDN s’adaptent facilement.
• Course de diplomation. Les bots automatisés surveillent quote_reserve_real et font la course avant Graduate dans un ou deux emplacements du franchissement du seuil. C’est bénin — cela ne leur coûte que le loyer — mais cela signifie que votre interface utilisateur doit traiter les transitions status comme des événements rapides.

​

Où aller ensuite

• products/launchlab/bonding-curve — mathématiques de la courbe.
• products/cpmm/code-demos — quoi faire avec le pool résultant.
• user-flows/launch-token-launchlab — le guide de lancement de token de bout en bout, y compris les étapes hors chaîne.

Sources :

• Raydium SDK v2
• Source du programme Raydium LaunchLab