LaunchLab-Code-Demos

End-to-End TypeScript: Starten Sie einen LaunchLab-Launch, kaufen und verkaufen Sie auf der Bonding Curve, graduieren Sie in einen CPMM-Pool und sammeln Sie Creator-Gebühren.

Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.

Englische Version ansehen →

Versionsbanner.

• SDK: @raydium-io/raydium-sdk-v2@0.2.42-alpha
• Cluster: Solana mainnet-beta
• Program ID: siehe reference/program-addresses
• Zuletzt überprüft: 2026-04

Fixieren Sie die SDK-Version in Ihrer package.json. Die Bonding-Curve-Schnittstelle hat sich zwischen Minor-Releases weiterentwickelt.

​

Setup

Die Demos hier spiegeln Dateien in raydium-sdk-V2-demo/src/launchpad wider. Das Bootstrap folgt der config.ts.template des Demo-Repos:

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;

​

Einen Launch erstellen

Quelle: src/launchpad/createMint.ts (und createBonkMintApi.ts für die API-gesteuerte Bonk-Variante)

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

const { execute, extInfo } = await raydium.launchpad.createLaunchpad({
  programId: /* LaunchLab program ID from reference/program-addresses */,
  // Token metadata for the new base mint:
  name:   "Example Token",
  symbol: "EXMPL",
  uri:    "https://example.com/metadata.json",
  decimals: 6,

  // Curve params:
  curveType: 0,                                      // 0 = quadratic
  supply:    new BN(1_000_000_000).mul(new BN(10).pow(new BN(6))), // 1B base (6 dec)
  graduationFractionBps: 8000,                       // 80% → graduation
  initialK:  new BN("40"),                           // curve shape parameter

  // Quote side:
  quoteMint: NATIVE_MINT,                            // WSOL
  openTime:  new BN(Math.floor(Date.now() / 1000) + 60),  // opens in 1min

  // Fee policy:
  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);

Hinweise:

• initialK ist der Skalierungsfaktor für die quadratische Kurve. Passen Sie ihn an, um einen bestimmten CPMM-Eröffnungspreis bei der Graduation anzusteuern. Siehe products/launchlab/bonding-curve für die Herleitung.
• Das SDK erstellt den Base-Mint, die Metadaten-PDA und beide Vaults in einer einzigen Transaktion. Es kann 1232 Bytes überschreiten, wenn der Metadaten-URI lang ist; in diesem Fall teilt das SDK in zwei Transaktionen auf.
• Nach Initialize ist der Launch nicht handelbar, bis openTime erreicht ist. Setzen Sie openTime eine oder zwei Minuten in die Zukunft, um Front-Runnern weniger Chancen zu geben, den ersten Kauf zu schnappen.

​

Launch-Status abrufen

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 gibt den dekodierten LaunchState plus den berechneten „Fortschritt zur Graduation”-Bruch als Decimal zurück.

​

Kauf — exakte Quote rein

Quelle: src/launchpad/buy.ts

const quoteIn        = new BN(1).mul(new BN(10).pow(new BN(9)));  // 1 SOL
const minimumBaseOut = new BN(0);  // accept any; tighten for production

// Preview the quote off-chain so your UI can show expected base_out:
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 spiegelt den On-Chain-Newton-Solver (quadratische Kurve) oder die geschlossene CPMM-Inverse (curve_type 1) wider. Verwenden Sie es, um das UI-Feld „Sie erhalten” zu füllen.

​

Kauf — exakte Base raus

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)));          // cap at 2 SOL

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

await execute({ sendAndConfirm: true });

Nützlich für „Kaufe genau X Token”-UIs. Lehnt mit ExceededSlippage ab, wenn sich die Kurve so weit bewegt hat, dass die Quote-Anforderung jetzt maximumQuoteIn überschreitet.

​

Verkauf

Quelle: 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 });

Der Verkaufspfad der Kurve ist symmetrisch zum Kaufpfad: Das Reduzieren von base_sold um baseIn gibt quote_out gleich der integrierten Fläche unter der Kurve zwischen base_sold − baseIn und base_sold, minus der Verkaufsgebühr.

​

Automatische Graduation beim Schwellenwert-Kauf

Das SDK verkettete eine Graduate-Anweisung in der buy*-Transaktion, wenn es erkennt, dass der Post-Buy-Status den Schwellenwert überschreitet:

const { execute, willGraduate } = await raydium.launchpad.buyExactIn({
  launchInfo: launch,
  quoteIn: new BN(100).mul(new BN(10).pow(new BN(9))),    // large buy
  minimumBaseOut: new BN(0),
  txVersion: TxVersion.V0,
  autoGraduate: true,                                      // default
});

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

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

Da Graduate erlaubnisfrei ist, kann jeder (einschließlich eines MEV-Bots) versuchen, die erste Graduate nach dem Schwellenwertüberschreitung zu landen — typischerweise Sekunden später, nicht Minuten. Der Erste zahlt nur die Miete für die CPMM-Pool-Konten; sie erhalten keinen anderen Vorteil.

​

Manuelle Graduate

Wenn autoGraduate ausgeschaltet war oder die Schwellenwert-Überschreitungs-Transaktion fehlgeschlagen ist, können Sie die Graduation separat auslösen:

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

await execute({ sendAndConfirm: true });

Wird mit NotAtThreshold zurückgewiesen, wenn quote_reserve_real < quote_reserve_target zum Zeitpunkt der Einreichung. Wiederholung sicher — ein zweiter Graduate-Versuch nach Erfolg wird mit NotActive zurückgewiesen.

​

Creator-Gebühren einziehen

Quelle: src/launchpad/claimCreatorFee.ts (einzelner Mint) und collectAllCreatorFees.ts (Batch)

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

await execute({ sendAndConfirm: true });

Überträgt den aufgelaufenen Creator-Gebühren-Zähler-Quote-Betrag auf das ATA des Creators auf dem Quote-Mint. Kann vor oder nach der Graduation aufgerufen werden; verwenden Sie es regelmäßig, anstatt auf einen riesigen Saldo zu warten.

​

Einen Launch durch seinen Lebenszyklus verfolgen

Alles zusammen könnte ein Überwachungsskript so aussehen:

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));
  }
}

​

Konfigurationen und Pools über gRPC überwachen

Quelle: src/grpc/launchpadPoolInfo.ts

Abonniert das LaunchLab-Programm über Yellowstone gRPC und protokolliert jedes GlobalConfig- und PoolState-Update mit dem Token-Programm jedes Mints. Zwei datasize-Filter auf einem accounts-Abonnement trennen die beiden Kontotypen, sodass ein einzelner Stream beide abdeckt.

Die Demo ist die kürzeste korrekte Referenz zum Klassifizieren der Mints eines Launches, was die Token-2022-Quote-Mint-Veröffentlichung notwendig macht:

• Pools werden direkt aus PoolState.token_program_flag klassifiziert, wobei Bit0 für den Base-Mint und Bit1 für den Quote-Mint dekodiert werden, ohne dass ein Mint-Abruf erforderlich ist. Das Testen des gesamten Bytes gegen 0 — was ausreichend war, während Quote-Mints nur Legacy waren — missinterpretiert einen Legacy-Base-Mint als Token-2022, wenn der Quote-Mint Token-2022 ist.
• Configs können auf diese Weise nicht klassifiziert werden: Ein GlobalConfig speichert die Adresse seines Quote-Mints und kein Programm-Flag, daher liest die Demo das Owner-Feld des Mint-Kontos einmal und speichert es pro Mint.

Es führt auch eine Gegenprüfung zwischen den beiden durch, was eine nützliche Assertion ist, um in Ihrem eigenen Indexer zu behalten. Beachten Sie, dass „create” versus „update” aus den eigenen Caches der Demo abgeleitet wird, die beim Start aus getProgramAccounts gespeichert werden; wenn diese Seeding deaktiviert ist, lesen Sie „create” als „zuerst auf diesem Stream gesehen”.

gRPC-Zugriff ist nicht Teil der öffentlichen RPC-Oberfläche — siehe die src/grpc/README.md des Demo-Repos.

​

Rust CPI

Das Aufrufen von LaunchLab aus Ihrem eigenen Anchor-Programm ist selten (die meisten Launch-Integrationen sind nur TS-seitig). Falls Sie dies tun, wird das Programm mit einer Anchor-Crate raydium_launchlab mit cpi::accounts::Buy, cpi::accounts::Sell usw. ausgeliefert — das Muster spiegelt die CPMM-/CLMM-CPI-Beispiele wider. Siehe sdk-api/rust-cpi für eine verallgemeinerte Vorlage, sobald diese Website gefüllt ist.

​

Fallstricke

• Fee-Split-Arithmetik Off-by-One. Wenn total_share nicht genau lp_share + creator_share + protocol_share ist, wird Initialize mit InvalidFeeShares zurückgewiesen. Setzen Sie totalShare gleich der Summe.
• Verwendung eines nicht zulässigen Quote-Mints. launch_config.allowed_quote_mints ist eine feste Liste; die Übergabe eines anderen Mints wird zurückgewiesen. Überprüfen Sie zuerst mit raydium.launchpad.getConfig().
• Metadatengröße. Lange uri-Strings drücken die Metaplex-CPI über das Budget. Halten Sie uri unter ~200 Zeichen — die meisten CDN-gehosteten JSON-Metadaten passen leicht.
• Graduations-Rennen. Automatisierte Bots überwachen quote_reserve_real und front-run Graduate innerhalb eines oder zwei Slots nach dem Schwellenwertüberschreitung. Dies ist harmlos — es kostet sie nur Miete — aber es bedeutet, dass Ihre UI status-Übergänge als schnelle Ereignisse behandeln sollte.

​

Wo es weitergeht

• products/launchlab/bonding-curve — Kurven-Mathematik.
• products/cpmm/code-demos — was Sie mit dem resultierenden Pool tun können.
• user-flows/launch-token-launchlab — der End-to-End-Leitfaden zum Starten eines Tokens, einschließlich Off-Chain-Schritte.

Quellen:

• Raydium SDK v2
• Raydium LaunchLab-Programmquelle