Demostraciones de código de LaunchLab

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;

import {
  LAUNCHPAD_PROGRAM,
  DEVNET_PROGRAM_ID,
  LaunchpadConfig,
  getPdaLaunchpadConfigId,
} from "@raydium-io/raydium-sdk-v2";
import { Keypair, PublicKey } from "@solana/web3.js";
import { NATIVE_MINT } from "@solana/spl-token";

const programId = LAUNCHPAD_PROGRAM;          // devnet: DEVNET_PROGRAM_ID.LAUNCHPAD_PROGRAM

// El mint base es un keypair que generas y firmas.
const pair  = Keypair.generate();
const mintA = pair.publicKey;

// Vincula una GlobalConfig: (mint de cotización, curve_type, índice).
const configId = getPdaLaunchpadConfigId(programId, NATIVE_MINT, 0, 0).publicKey;
const configData = await raydium.connection.getAccountInfo(configId);
if (!configData) throw new Error("config not found");
const configInfo = LaunchpadConfig.decode(configData.data);
const mintBInfo = await raydium.token.getTokenInfo(configInfo.mintB);

const { execute, transactions, extInfo } = await raydium.launchpad.createLaunchpad({
  programId,
  mintA,
  decimals: 6,
  name:   "Example Token",
  symbol: "EXMPL",                 // debe tener 10 caracteres o menos
  uri:    "https://example.com/metadata.json",   // debe ser no vacío
  migrateType: "amm",              // "amm" | "cpmm"

  configId,
  configInfo,                      // opcional; el SDK relee configId cuando se omite
  mintBDecimals: mintBInfo.decimals,
  mintBProgram:  new PublicKey(mintBInfo.programId),

  // Primera compra opcional en el mismo lote.
  createOnly: true,                // true = crear solo el mint
  buyAmount:  new BN(1000),        // ignorado cuando createOnly es true
  slippage:   new BN(100),         // 100 = 1%

  extraSigners: [pair],            // el keypair del mint base debe firmar
  txVersion: TxVersion.V0,

  // Los valores predeterminados provienen de los valores predeterminados de la API de la configuración vinculada; anula solo si es necesario:
  // supply:            new BN(1_000_000_000_000_000),
  // totalSellA:        new BN(793_100_000_000_000),
  // totalFundRaisingB: new BN(85_000_000_000),   // 85 SOL cuando mintB es SOL
  // totalLockedAmount: new BN(0),
  // cliffPeriod:       new BN(0),                // segundos
  // unlockPeriod:      new BN(0),                // segundos
  // platformId:        new PublicKey("4Bu96XjU84XjPDSpveTVf6LYGCkfW5FK7SNkREWcEfV4"), // el de Raydium, el predeterminado
});

// createLaunchpad devuelve MÚLTIPLES transacciones - ejecútalas en orden.
const { txIds } = await execute({ sequentially: true });
console.log("Pool:", extInfo.address.poolId.toBase58());
console.log("Base mint:", mintA.toBase58());
console.log("Create txs:", txIds);

import { getPdaLaunchpadPoolId, Curve } from "@raydium-io/raydium-sdk-v2";

const poolId = getPdaLaunchpadPoolId(programId, mintA, NATIVE_MINT).publicKey;
const poolInfo = await raydium.launchpad.getRpcPoolInfo({ poolId });

console.log("status:", poolInfo.status);
console.log("base sold:", poolInfo.realA.toString(), "/", poolInfo.totalSellA.toString());
console.log("quote raised:", poolInfo.realB.toString(), "/", poolInfo.totalFundRaisingB.toString());

// Precio spot actual en la curva.
const price = Curve.getPrice({
  poolInfo,
  curveType: poolInfo.configInfo.curveType,
  decimalA: poolInfo.mintDecimalsA,
  decimalB: poolInfo.mintDecimalsB,
});
console.log("price:", price.toString());

import { Curve, PlatformConfig, toTransferFeeConfig } from "@raydium-io/raydium-sdk-v2";

const inAmount = new BN(1).mul(new BN(10).pow(new BN(9)));   // 1 SOL
const slippage = new BN(100);                                 // 100 = 1%

const poolInfo = await raydium.launchpad.getRpcPoolInfo({ poolId });
const platformData = await raydium.connection.getAccountInfo(poolInfo.platformId);
const platformInfo = PlatformConfig.decode(platformData!.data);

const mintInfo  = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(poolInfo.mintB);
const epochInfo = await raydium.connection.getEpochInfo();

// Vista previa fuera de cadena — refleja la matemática de la curva en cadena.
const res = Curve.buyExactIn({
  poolInfo,
  amountB: inAmount,
  protocolFeeRate: poolInfo.configInfo.tradeFeeRate,
  platformFeeRate: platformInfo.feeRate,
  creatorFeeRate:  platformInfo.creatorFeeRate,
  curveType:       poolInfo.configInfo.curveType,
  shareFeeRate:    new BN(0),
  transferFeeConfigA: mintInfo.extensions.feeConfig  ? toTransferFeeConfig(mintInfo,  epochInfo.epoch) : undefined,
  transferFeeConfigB: mintBInfo.extensions.feeConfig ? toTransferFeeConfig(mintBInfo, epochInfo.epoch) : undefined,
  slot: await raydium.connection.getSlot(),
});
console.log("expected out:", res.amountA.amount.sub(res.amountA.fee ?? new BN(0)).toString());

const { execute, extInfo } = await raydium.launchpad.buyToken({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  transferFeeConfigB: toTransferFeeConfig(mintBInfo, epochInfo.epoch),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,
  buyAmount:       inAmount,
  slippage,                       // BN en bps; el SDK deriva minMintAAmount de él
  txVersion: TxVersion.V0,
});

console.log("expected receive amount:", extInfo.decimalOutAmount.toString());
const { txId } = await execute({ sendAndConfirm: true });
console.log("Buy tx:", txId);

const { execute, extInfo } = await raydium.launchpad.buyTokenExactOut({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,

  outAmount:    new BN(1_000_000).mul(new BN(10).pow(new BN(6))),  // 1M base
  maxBuyAmount: new BN(2).mul(new BN(10).pow(new BN(9))),          // límite en 2 SOL
  slippage:     new BN(100),

  txVersion: TxVersion.V0,
});

console.log("out:", extInfo.outAmount.toString(), "max spent:", extInfo.maxSpentAmount.toString());
await execute({ sendAndConfirm: true });

const inAmount = new BN(500_000).mul(new BN(10).pow(new BN(6)));  // 0.5M base

const res = Curve.sellExactIn({
  poolInfo,
  amountA: inAmount,
  protocolFeeRate: poolInfo.configInfo.tradeFeeRate,
  platformFeeRate: platformInfo.feeRate,
  creatorFeeRate:  platformInfo.creatorFeeRate,
  curveType:       poolInfo.configInfo.curveType,
  shareFeeRate:    new BN(0),
  transferFeeConfigA: mintInfo.extensions.feeConfig  ? toTransferFeeConfig(mintInfo,  epochInfo.epoch) : undefined,
  transferFeeConfigB: mintBInfo.extensions.feeConfig ? toTransferFeeConfig(mintBInfo, epochInfo.epoch) : undefined,
  slot: await raydium.connection.getSlot(),
});
console.log("expected quote out:", res.amountB.toString());

const { execute } = await raydium.launchpad.sellToken({
  programId,
  mintA,
  mintAProgram: new PublicKey(mintInfo.programId),
  mintB:        poolInfo.mintB,
  mintBProgram: new PublicKey(mintBInfo.programId),
  poolInfo,
  configInfo:      poolInfo.configInfo,
  platformFeeRate: platformInfo.feeRate,
  sellAmount:      inAmount,
  slippage:        new BN(100),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

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

const { execute } = await raydium.launchpad.claimCreatorFee({
  programId,
  mintB: NATIVE_MINT,          // el mint de cotización a reclamar
  // mintBProgram: TOKEN_PROGRAM_ID,   // o TOKEN_2022_PROGRAM_ID
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

async function watch(poolId: PublicKey) {
  const startStatus = (await raydium.launchpad.getRpcPoolInfo({ poolId })).status;

  while (true) {
    const p = await raydium.launchpad.getRpcPoolInfo({ poolId });
    const progress = Number(p.realB.toString()) / Number(p.totalFundRaisingB.toString());

    console.log(`status=${p.status}`, `progress=${(progress * 100).toFixed(2)}%`);

    if (p.status !== startStatus) {
      console.log("status changed - the launch has migrated; switch to the pool page");
      break;
    }
    await new Promise((r) => setTimeout(r, 10_000));
  }
}