Demonstrações de código do LaunchLab

TypeScript end-to-end: crie um lançamento no LaunchLab, compre e venda na curva de ligação, forme um pool CPMM e colete taxas do criador.

Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.

Ver versão em inglês →

Banner de versão.

• SDK: @raydium-io/raydium-sdk-v2@0.2.42-alpha
• Cluster: Solana mainnet-beta
• Program ID: veja reference/program-addresses
• Última verificação: 2026-04

Fixe a versão do SDK no seu package.json. A interface da curva de ligação evoluiu entre versões menores.

​

Configuração

As demonstrações aqui espelham arquivos em raydium-sdk-V2-demo/src/launchpad. O bootstrap segue o config.ts.template do repositório de demonstração:

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;

​

Criar um lançamento

Fonte: src/launchpad/createMint.ts (e createBonkMintApi.ts para a variante Bonk orientada por API)

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

Notas:

• initialK é o fator de escala para a curva quadrática. Ajuste-o para atingir um preço CPMM de abertura específico na formação. Veja products/launchlab/bonding-curve para a derivação.
• O SDK lida com a criação do mint base, o PDA de metadados e ambos os vaults em uma única transação. Pode exceder 1232 bytes se o URI de metadados for longo; nesse caso, o SDK se divide em duas transações.
• Após Initialize, o lançamento não é negociável até openTime. Defina openTime um ou dois minutos à frente para dar aos front-runners menos chance de pegar a primeira compra.

​

Buscar estado do lançamento

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 retorna o LaunchState decodificado mais a fração “progresso em direção à formação” calculada como um Decimal.

​

Comprar — entrada de quote exata

Fonte: 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 espelha o solver Newton on-chain (curva quadrática) ou o inverso CPMM de forma fechada (curve_type 1). Use-o para preencher o campo “Você recebe” da UI.

​

Comprar — saída de base exata

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

Útil para UIs “compre exatamente X tokens”. Rejeita com ExceededSlippage se a curva se moveu o suficiente para que o requisito de quote agora exceda maximumQuoteIn.

​

Vender

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

O caminho de venda da curva é simétrico ao caminho de compra: reduzir base_sold por baseIn retorna quote_out igual à área integrada sob a curva entre base_sold − baseIn e base_sold, menos a taxa de venda.

​

Formação automática na compra de cruzamento de limite

O SDK encadeia uma instrução Graduate dentro da transação buy* quando detecta que o estado pós-compra cruzará o limite:

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

Como Graduate é sem permissão, qualquer pessoa (incluindo um bot MEV) pode correr para colocar o primeiro Graduate após o limite ser cruzado — normalmente segundos depois, não minutos. O primeiro a chegar apenas paga o aluguel das contas do pool CPMM; não recebe nenhum outro benefício.

​

Graduate manual

Se autoGraduate estava desativado ou a transação de cruzamento de limite falhou, você pode disparar a formação separadamente:

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

await execute({ sendAndConfirm: true });

Reverte com NotAtThreshold se quote_reserve_real < quote_reserve_target no momento do envio. Seguro para retry — uma segunda tentativa de Graduate após o sucesso reverte com NotActive.

​

Coletar taxas do criador

Fonte: src/launchpad/claimCreatorFee.ts (mint único) e collectAllCreatorFees.ts (em lote)

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

await execute({ sendAndConfirm: true });

Transfere o valor do contador de taxa do criador acumulado para o ATA do criador no mint de quote. Pode ser chamado pré ou pós-formação; use-o periodicamente em vez de esperar um saldo enorme se acumular.

​

Rastrear um lançamento através de seu ciclo de vida

Juntando tudo, um script de monitoramento pode parecer:

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

​

Assistir configurações e pools sobre gRPC

Fonte: src/grpc/launchpadPoolInfo.ts

Se inscreve no programa LaunchLab sobre Yellowstone gRPC e registra cada atualização de GlobalConfig e PoolState com o programa de token de cada mint. Dois filtros datasize em uma assinatura accounts separam os dois tipos de conta, então um único stream cobre ambos.

A demonstração é a referência mais curta e correta para classificar os mints de um lançamento, o que a versão de quote-mint do Token-2022 torna necessário:

• Pools são classificados diretamente de PoolState.token_program_flag, decodificando bit0 para o mint base e bit1 para o mint de quote sem nenhuma busca de mint. Testar todo o byte contra 0 — que era suficiente enquanto os mints de quote eram apenas legados — interpreta mal um mint base legado como Token-2022 sempre que o mint de quote é Token-2022.
• Configs não podem ser classificados dessa forma: um GlobalConfig armazena o endereço do mint de quote e nenhuma flag de programa, então a demonstração lê o proprietário da conta de mint uma vez e o armazena em cache por mint.

Também faz verificação cruzada dos dois um contra o outro, o que é uma asserção útil para manter em seu próprio indexador. Observe que create versus update é inferido dos próprios caches da demonstração, inicializados na inicialização a partir de getProgramAccounts; com essa inicialização desativada, leia “create” como “primeiro visto neste stream”.

O acesso gRPC não faz parte da superfície RPC pública — veja src/grpc/README.md do repositório de demonstração.

​

Rust CPI

Chamar LaunchLab a partir de seu próprio programa Anchor é raro (a maioria das integrações de lançamento são apenas do lado TS). Se você fizer isso, o programa fornece um crate Anchor raydium_launchlab com cpi::accounts::Buy, cpi::accounts::Sell, etc. — o padrão espelha os exemplos de CPI CPMM / CLMM. Veja sdk-api/rust-cpi para um modelo generalizado quando este site for preenchido.

​

Armadilhas

• Arredondamento de divisão de taxa desligado por um. Se total_share não for exatamente lp_share + creator_share + protocol_share, Initialize reverte com InvalidFeeShares. Defina totalShare igual à soma.
• Usando um mint de quote não permitido. launch_config.allowed_quote_mints é uma lista fixa; passar qualquer outro mint reverte. Verifique com raydium.launchpad.getConfig() primeiro.
• Tamanho de metadados. Strings uri longas empurram o CPI do Metaplex além do orçamento. Mantenha uri com menos de ~200 caracteres — a maioria dos metadados JSON hospedados em CDN se encaixa facilmente.
• Corrida de formação. Bots automatizados monitoram quote_reserve_real e front-run Graduate dentro de um ou dois slots do cruzamento de limite. Isso é inócuo — apenas custa aluguel — mas significa que sua UI deve tratar transições de status como eventos rápidos.

​

Para onde ir a seguir

• products/launchlab/bonding-curve — matemática da curva.
• products/cpmm/code-demos — o que fazer com o pool resultante.
• user-flows/launch-token-launchlab — o guia end-to-end de lançamento de token, incluindo etapas off-chain.

Fontes:

• Raydium SDK v2
• Fonte do programa Raydium LaunchLab