Saltar para o conteúdo principal

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.

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

O que você precisa

  • Token mint — o token que você quer vender. Deve estar recém-criado com:
    • Total supply cunhado na sua carteira (para que você possa depositar na curva).
    • Autoridade de cunhagem revogada antes do lançamento (caso contrário, o preço da curva pode ser manipulado por novos cunhagens).
  • Metadados — nome, símbolo, imagem, links sociais. Metadados Metaplex ou similares.
  • Carteira — ~1 SOL para aluguel de criação + financiamento do vault + taxas de prioridade (a própria graduação é paga pelo graduador, não por você).
  • Decisões sobre:
    • Tipo de curva (quadrática vs CPMM com reservas virtuais).
    • Limite de graduação.
    • Política de descarte de LP (Burn / Lock / ToCreator).
    • Preço inicial e cap.

Escolha da curva

LaunchLab oferece suporte a duas famílias de curvas:

Quadrática (curve_type = 0)

O preço cresce quadraticamente com o supply vendido. Sensação clássica de “lançamento justo” — os compradores iniciais recebem uma vantagem de preço, os compradores finais pagam mais, o preço acelera suavemente.
price(s) = a * s^2 + b * s + c
onde s é o supply vendido. Tipicamente a > 0 (convexa). O spread entre preços iniciais e de graduação é determinístico dados a, b, c e o cap. Melhor para: lançamentos de novidade, memes, projetos comunitários.

CPMM com reservas virtuais (curve_type = 1)

Emula um AMM de produto constante usando reservas virtuais — a curva se comporta como um CPMM com x * y = k mas o pool começa seeded com tokens sintéticos que nunca são retirados.
price = virtual_quote_reserve / virtual_base_reserve
Conforme os compradores adquirem, virtual_base_reserve diminui e virtual_quote_reserve aumenta — a curva parece idêntica ao que o CPMM pós-graduação parecerá. Transição mais suave. Melhor para: lançamentos que querem continuidade de preço pós-graduação previsível.

Walkthrough da UI

Em raydium.io/launchpad/create:
  1. Token. Cole o endereço do mint. A UI busca metadados e os exibe.
  2. Tipo de curva. Escolha quadrática ou CPMM virtual; a UI mostra um gráfico de preço para cada uma.
  3. Limite de graduação. Padrão: a curva termina após todo total_base_supply ter sido vendido. Alternativa: terminar em um graduation_quote_amount específico (ex: 85 SOL).
  4. Quote mint. SOL (padrão), USDC ou qualquer outro mint. SOL é o padrão.
  5. Política de descarte de LP:
    • Burn — tokens LP enviados para um endereço inutilizável na graduação. O criador não pode sacar liquidez; os usuários confiam no pool para sempre.
    • Lock — tokens LP enviados para um escrow com bloqueio temporal por lock_duration.
    • ToCreator — tokens LP enviados para o criador. Mais flexível, menos minimizador de confiança.
    Os lançamentos mais respeitados usam Burn.
  6. Revisão. A UI resume: faixa de preço esperada, levantamento inicial se a curva se esgotar, configuração CPMM pós-graduação.
  7. Assinar. Uma transação cria o estado de lançamento + vault base + vault quote, transferindo total_base_supply da sua carteira para o vault base.

Walkthrough programático

import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";

const raydium = await Raydium.load({ connection, owner, cluster: "mainnet" });

const baseMint  = new PublicKey("MyNewToken...");
const quoteMint = new PublicKey("So11111111111111111111111111111111111111112"); // SOL

const { execute, extInfo } = await raydium.launchpad.createLaunchpad({
  programId:      LAUNCHPAD_PROGRAM_ID,
  baseMint,
  quoteMint,
  curveType:      0,                           // quadratic
  totalBaseSupply:    new BN("1000000000000000000"),   // 1B tokens with 9 decimals
  graduationQuoteAmount: new BN("85000000000"),         // 85 SOL
  lpDisposalPolicy:   "Burn",
  priceCurveParams: {
    a: new BN("1"),
    b: new BN("0"),
    c: new BN("0"),
  },
  startTime: new BN(Math.floor(Date.now() / 1000) + 300),  // start in 5 min
  txVersion: TxVersion.V0,
  computeBudgetConfig: { units: 400_000, microLamports: 50_000 },
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Launch ID:", extInfo.launchId.toBase58());
console.log("Base vault:", extInfo.baseVault.toBase58());
console.log("Quote vault:", extInfo.quoteVault.toBase58());

Monitoramento pré-graduação

Acompanhe a atividade através da API:
const status = await fetch(
  `https://api-v3.raydium.io/launchpad/status?launchId=${launchId}`
).then(r => r.json());

console.log("Vendido até agora:",       status.baseSold.toString());
console.log("Quote levantado:",      status.quoteRaised.toString());
console.log("Preço atual:",     status.currentPriceUsd);
console.log("Progresso de graduação:", status.graduationProgress, "%");
Ou decodifique o estado on-chain diretamente:
const launchState = await raydium.launchpad.fetchLaunchState(launchId);
console.log({
  baseSold:   launchState.baseSold.toString(),
  quoteHeld:  launchState.quoteHeld.toString(),
  graduated:  launchState.graduated,
});

Métricas para monitorar

  • Taxa de venda: percentual de base vendido. O limite de graduação é típicamente em 80–100% vendido.
  • Preço atual: derivado da curva no baseSold atual.
  • Compradores únicos: contagem de pagadores distintos via indexador.
  • Taxa de compra vs venda: lançamentos iniciais veem pressão de compra pesada que desacelera.
Se a taxa de venda for <10% após 24 horas, considere se o marketing é adequado. LaunchLab não resgata lançamentos com pouca publicidade.

Graduação

A graduação é uma transação separada, chamável por qualquer pessoa (geralmente a primeira pessoa a notar que o limite foi atingido ganha o pequeno graduation_bounty). Nenhuma ação necessária de você como criador além da configuração inicial.

O que a graduação faz

  1. Lê os saldos do vault.
  2. Fecha a curva (não há mais compras/vendas contra ela).
  3. Cria um novo pool CPMM com os saldos do vault como liquidez inicial.
  4. Cunha tokens LP iniciais com base nos saldos do vault.
  5. Descarta os tokens LP conforme a política configurada (Burn / Lock / ToCreator).
Após a graduação, o pool CPMM está ativo e as negociações ocorrem através do roteamento normal do Raydium.

Monitoramento para graduação

const launchState = await raydium.launchpad.fetchLaunchState(launchId);
if (launchState.graduated) {
  const cpmmPoolId = launchState.graduatedCpmmPool;
  console.log("Graduado para pool CPMM:", cpmmPoolId.toBase58());
}

Graduação manual

Se ninguém reivindicar o bounty e você quiser forçar a graduação, você pode chamá-la você mesmo:
await raydium.launchpad.graduate({
  launchId,
  txVersion: TxVersion.V0,
  computeBudgetConfig: { units: 600_000, microLamports: 100_000 },
});
A graduação usa CU significativo; orce 600k.

Pós-graduação

Verifique o pool CPMM

const pool = await raydium.cpmm.getPoolInfoFromRpc({ poolId: cpmmPoolId });
console.log("Preço CPMM:", pool.poolInfo.price);
console.log("TVL CPMM:  ", pool.poolInfo.tvl);
O pool CPMM deve ter (aproximadamente):
  • Saldo de token base: total_base_supply - baseSold + remanescente da curva.
  • Saldo de token quote: quoteRaised - graduationFee.
  • Preço: corresponde ao último preço da curva.

Verifique descarte de LP

  • Burn: O mint de LP mostra envio para 1nc1nerator11111111111111111111111111111111 ou similar.
  • Lock: Tokens LP no PDA do escrow com timestamp de desbloqueio.
  • ToCreator: Tokens LP na carteira do criador.

Colete taxas do criador

Se você configurou uma participação em taxa do criador, chame periodicamente:
await raydium.launchpad.collectCreatorFees({
  launchId,
  txVersion: TxVersion.V0,
});
As taxas acumulam de trades de curva pré-graduação e do pool CPMM pós-graduação (se ToCreator LP).

Lista de verificação de anúncio

O anúncio pós-graduação deve incluir:
  • Hash da transação de graduação.
  • Novo ID de pool CPMM.
  • Prova de descarte de LP (tx de burn / tx de lock / carteira do criador).
  • ETA de cobertura de agregador (carteiras geralmente indexam em 5 minutos).
  • Verificação de contrato de token (corresponder endereço do mint em todos os canais de anúncio).

Armadilhas

1. Autoridade de cunhagem não revogada

Se baseMint.mintAuthority ainda for uma chave que você controla, você pode cunhar novo supply e vender para sua própria curva. Lançamentos que não revogaram são comumente sinalizados como alto risco ou não verificados por agregadores e sites de listagem. Revogue antes de lançar.

2. Parâmetros de curva incorretos

Curvas quadráticas com a muito alto tornam tokens iniciais gratuitos (preço ≈ 0) e tokens posteriores absurdos. Curvas com a muito baixo tornam a curva quase linear (perdem a sensação de “bonding”). Teste parâmetros em devnet primeiro.

3. Limite de graduação muito alto

Se a graduação exigir mais capital do que a demanda realista, a curva nunca se forma e os compradores ficam presos com tokens que só podem vender de volta para a curva (a piores preços). Escolha um limite que você possa realmente atingir.

4. Scams de quote mint

Se seu quote mint for um token personalizado (não SOL/USDC), os usuários não confiarão. Fique com SOL ou USDC para quote.

5. Esqueceu de financiar o vault base

O SDK transfere totalBaseSupply da sua carteira na criação. Se sua carteira não tiver, a tx é revertida. Confirme o saldo antes de assinar.

6. Descarte de LP = Burn é irreversível

Uma vez que LP é enviado para 1nc1nerator, ninguém pode sacar liquidez, inclusive você. Este é o objetivo — minimização de confiança. Não escolha Burn se você não tiver certeza.

7. Tier de taxa CPMM pós-graduação

O pool graduado usa a configuração padrão CPMM do LaunchLab (0.25%). Se você quisesse 1% ou 0.01%, você precisaria criar um segundo pool CPMM você mesmo pós-graduação e migrar liquidez — desajeitado e fragmentando. Aceite o padrão, ou lance via criação direta de CPMM em vez de LaunchLab.

Ponteiros

Fontes:
  • Módulo launchpad do Raydium SDK v2.
  • Status de lançamento via endpoints api-v3.raydium.io.