Demostraciones de código de LaunchLab

TypeScript de extremo a extremo: crea un lanzamiento en LaunchLab, compra y vende en la curva de vinculación, gradúa a un pool CPMM y cobra comisiones del creador.

Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.

Ver versión en inglés →

Banner de versión.

• SDK: @raydium-io/raydium-sdk-v2@0.2.42-alpha
• Cluster: Solana mainnet-beta
• ID del programa: consulta reference/program-addresses
• Última verificación: 2026-04

Fija la versión del SDK en tu package.json. La interfaz de la curva de vinculación ha evolucionado entre versiones menores.

​

Configuración

Las demostraciones aquí reflejan archivos en raydium-sdk-V2-demo/src/launchpad. El arranque sigue el config.ts.template del repositorio de demostración:

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;

​

Crear un lanzamiento

Fuente: src/launchpad/createMint.ts (y createBonkMintApi.ts para la variante Bonk impulsada por API)

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

const { execute, extInfo } = await raydium.launchpad.createLaunchpad({
  programId: /* ID del programa LaunchLab de reference/program-addresses */,
  // Metadatos del token para el nuevo mint base:
  name:   "Example Token",
  symbol: "EXMPL",
  uri:    "https://example.com/metadata.json",
  decimals: 6,

  // Parámetros de la curva:
  curveType: 0,                                      // 0 = cuadrática
  supply:    new BN(1_000_000_000).mul(new BN(10).pow(new BN(6))), // 1B base (6 dec)
  graduationFractionBps: 8000,                       // 80% → graduación
  initialK:  new BN("40"),                           // parámetro de forma de la curva

  // Lado de la cotización:
  quoteMint: NATIVE_MINT,                            // WSOL
  openTime:  new BN(Math.floor(Date.now() / 1000) + 60),  // abre en 1min

  // Política de comisiones:
  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);

Notas:

• initialK es el factor de escala para la curva cuadrática. Ajústalo para apuntar a un precio CPMM de apertura específico en la graduación. Consulta products/launchlab/bonding-curve para la derivación.
• El SDK maneja la creación del mint base, el PDA de metadatos y ambas bóvedas en una sola transacción. Puede exceder 1232 bytes si el URI de metadatos es largo; en ese caso, el SDK se divide en dos transacciones.
• Después de Initialize, el lanzamiento no es comercializable hasta openTime. Establece openTime un minuto o dos adelante para dar menos oportunidad a los adelantados de agarrar la primera compra.

​

Obtener el estado del lanzamiento

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 devuelve el LaunchState decodificado más la fracción calculada de “progreso hacia la graduación” como un Decimal.

​

Comprar — cotización exacta dentro

Fuente: src/launchpad/buy.ts

const quoteIn        = new BN(1).mul(new BN(10).pow(new BN(9)));  // 1 SOL
const minimumBaseOut = new BN(0);  // aceptar cualquiera; ajustar para producción

// Previsualiza la cotización fuera de la cadena para que tu UI pueda mostrar base_out esperado:
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 refleja el solucionador Newton en cadena (curva cuadrática) o la inversa CPMM de forma cerrada (curve_type 1). Úsalo para rellenar el campo de UI “Recibirás”.

​

Comprar — base exacta fuera

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)));          // límite en 2 SOL

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

await execute({ sendAndConfirm: true });

Útil para UIs de “compra exactamente X tokens”. Rechaza con ExceededSlippage si la curva se ha movido lo suficiente como para que el requisito de cotización ahora exceda maximumQuoteIn.

​

Vender

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

La ruta de venta de la curva es simétrica a la ruta de compra: reducir base_sold por baseIn devuelve quote_out igual al área integrada bajo la curva entre base_sold − baseIn y base_sold, menos la comisión de venta.

​

Graduación automática en la compra de cruce de umbral

El SDK encadena una instrucción Graduate dentro de la transacción buy* cuando detecta que el estado posterior a la compra cruzará el umbral:

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

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

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

Debido a que Graduate no requiere permiso, cualquiera (incluyendo un bot MEV) puede competir para aterrizar el primer Graduate después de que se cruce el umbral — típicamente segundos después, no minutos. El primer aterrizador solo paga la renta de las cuentas del pool CPMM; no obtienen ningún otro beneficio.

​

Graduate manual

Si autoGraduate estaba desactivado o la transacción de cruce de umbral falló, puedes disparar la graduación por separado:

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

await execute({ sendAndConfirm: true });

Revierte con NotAtThreshold si quote_reserve_real < quote_reserve_target en el momento del envío. Seguro para reintentos — un segundo intento de Graduate después del éxito revierte con NotActive.

​

Cobrar comisiones del creador

Fuente: src/launchpad/claimCreatorFee.ts (mint único) y collectAllCreatorFees.ts (por lotes)

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

await execute({ sendAndConfirm: true });

Transfiere la cantidad del contador de comisión del creador acumulada al ATA del creador en el mint de cotización. Se puede llamar antes o después de la graduación; úsalo periódicamente en lugar de esperar a que se acumule un saldo enorme.

​

Rastrear un lanzamiento a través de su ciclo de vida

Juntándolo todo, un script de monitoreo podría verse así:

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

​

Observar configuraciones y pools sobre gRPC

Fuente: src/grpc/launchpadPoolInfo.ts

Se suscribe al programa LaunchLab sobre gRPC de Yellowstone y registra cada actualización de GlobalConfig y PoolState con el programa de token de cada mint. Dos filtros datasize en una suscripción accounts separan los dos tipos de cuenta, por lo que un único flujo cubre ambos.

La demostración es la referencia más corta y correcta para clasificar los mints de un lanzamiento, lo que el lanzamiento de quote-mint de Token-2022 hace necesario:

• Pools se clasifican directamente desde PoolState.token_program_flag, decodificando bit0 para el mint base y bit1 para el mint de cotización sin obtener el mint en absoluto. Probar todo el byte contra 0 — que fue suficiente mientras los mints de cotización eran solo heredados — malinterpreta un mint base heredado como Token-2022 siempre que el mint de cotización sea Token-2022.
• Configs no se pueden clasificar de esa manera: un GlobalConfig almacena la dirección del mint de cotización y ninguna bandera de programa, por lo que la demostración lee el propietario de la cuenta del mint una vez y lo almacena en caché por mint.

También realiza una verificación cruzada de los dos entre sí, que es una aserción útil para mantener en tu propio indexador. Ten en cuenta que create versus update se infiere de los cachés propios de la demostración, sembrados al inicio desde getProgramAccounts; con esa siembra deshabilitada, lee “create” como “visto por primera vez en este flujo”.

El acceso a gRPC no es parte de la superficie RPC pública — consulta el src/grpc/README.md del repositorio de demostración.

​

CPI de Rust

Llamar a LaunchLab desde tu propio programa Anchor es raro (la mayoría de las integraciones de lanzamiento son solo del lado de TS). Si lo haces, el programa envía un crate Anchor raydium_launchlab con cpi::accounts::Buy, cpi::accounts::Sell, etc. — el patrón refleja los ejemplos de CPI de CPMM / CLMM. Consulta sdk-api/rust-cpi para una plantilla generalizada una vez que este sitio esté poblado.

​

Trampas

• Aritmética de división de comisiones fuera por uno. Si total_share no es exactamente lp_share + creator_share + protocol_share, Initialize revierte con InvalidFeeShares. Establece totalShare igual a la suma.
• Usar un mint de cotización no permitido. launch_config.allowed_quote_mints es una lista fija; pasar cualquier otro mint revierte. Verifica primero con raydium.launchpad.getConfig().
• Tamaño de metadatos. Las cadenas uri largas empujan el CPI de Metaplex sobre el presupuesto. Mantén uri bajo ~200 caracteres — la mayoría de los metadatos JSON alojados en CDN caben fácilmente.
• Carrera de graduación. Los bots automatizados monitorean quote_reserve_real y adelantan Graduate dentro de un slot o dos del cruce de umbral. Esto es benigno — solo les cuesta renta — pero significa que tu UI debe tratar las transiciones de status como eventos rápidos.

​

Dónde ir a continuación

• products/launchlab/bonding-curve — matemáticas de la curva.
• products/cpmm/code-demos — qué hacer con el pool resultante.
• user-flows/launch-token-launchlab — la guía de lanzamiento de token de extremo a extremo, incluyendo pasos fuera de la cadena.

Fuentes:

• Raydium SDK v2
• Fuente del programa Raydium LaunchLab