Règles de courbe LaunchLab

​

Le modèle mental

GlobalConfig       plancher du protocole      "supply >= 10M, taux de vente >= 20%, ..."
  └─ PlatformCurveRule   votre règle     "et sur ma plateforme : l'une de ces formes"
       └─ groupe de vérification    une forme     "supply = 1B ET levée de fonds dans [80, 90] SOL"
            └─ contrainte une vérification    "(Supply, Eq, 1_000_000_000)"

• Les contraintes à l’intérieur d’un groupe sont combinées avec ET. Toutes doivent être satisfaites.
• Les groupes à l’intérieur d’une règle sont combinés avec OU. Un lancement est autorisé dès qu’il satisfait un seul groupe.

​

Contraintes

pub struct ParamConstraint {
    pub field: u8,    // quel paramètre de lancement, voir le tableau ci-dessous
    pub op:    u8,    // 0 Eq, 1 Gte (min), 2 Lte (max), 3 Neq
    pub value: u128,
}

​

Champs

​

Les neuf modèles

​

1. Un palier standard

​

2. Une bande au lieu d’un nombre

​

3. Paliers côte à côte

​

4. Une bande de valorisation à la graduation

​

5. Un plancher de migration

​

6. Vesting que vous appliquez réellement

​

7. Gating par type de token

​

8. Un plafond de frais de transfert conditionnel

​

9. Une promo limitée dans le temps, programmée à l’avance

​

Restrictions de type de courbe

​

Vérifier avant d’envoyer

​

Avant un lancement : ces paramètres passeront-ils ?

import {
  checkLaunchAgainstCurveRule,
  getPdaPlatformCurveRule,
  LaunchpadCurveRuleBaseTokenProgram,
  LaunchpadCurveRuleField,
  PlatformCurveRule,
} from "@raydium-io/raydium-sdk-v2";
import BN from "bn.js";

const platformConfig = await raydium.launchpad.getPlatformConfig(platformConfigId);

// à 0 le programme ne lit pas du tout les règles, donc il n'y a rien à vérifier
if (platformConfig.restrictCurveParam !== 0) {
  const ruleId = getPdaPlatformCurveRule(programId, platformConfigId, configId).publicKey;
  const ruleAccount = await connection.getAccountInfo(ruleId);

  const result = checkLaunchAgainstCurveRule({
    // undefined quand le compte n'existe pas — la plateforme n'a écrit aucune règle pour cette config
    rule: ruleAccount === null ? undefined : PlatformCurveRule.decode(ruleAccount.data),
    context: {
      curveType: globalConfig.curveType,
      migrateType: 1,
      migrateCpmmFeeOn: 0,
      supply: new BN("1000000000000000"),
      totalSellA: new BN("793100000000000"),
      totalFundRaisingB: new BN("85000000000"),
      totalLockedAmount: new BN(0),
      cliffPeriod: new BN(0),
      unlockPeriod: new BN(0),
      baseTokenProgram: LaunchpadCurveRuleBaseTokenProgram.SplToken,
      // omettez transferFee entièrement quand le mint de base ne porte pas d'extension de frais de transfert
      unixTimestamp: new BN(Math.floor(Date.now() / 1000)),
    },
  });

  if (!result.ok) {
    // chaque groupe a rejeté le lancement ; chaque entrée liste toutes les contraintes défaillantes de ce groupe
    for (const group of result.groupFailures) {
      for (const c of group.unsatisfied) {
        console.log(
          `groupe ${group.groupId}: ${LaunchpadCurveRuleField[c.field]} est ${c.actual ?? "non calculable"},`,
          `la règle veut op ${c.op} ${c.value.toString()}`,
        );
      }
    }
  }
}

• Un compte de règle manquant, et une règle sans groupe, passent tous les deux. Tout comme un groupe sans contrainte. Passez rule: undefined pour un compte inexistant ; ne le traitez pas comme un rejet.
• Les valeurs non calculables échouent fermées. Une supply zéro n’a pas de taux, et un montant verrouillé plus grand que ce que la vente de courbe laisse n’a pas de montant de migration. actual revient undefined et la contrainte compte comme non satisfaite, exactement comme on-chain.
• Toutes les contraintes défaillantes sont rapportées, pas seulement la première. Le programme court-circuite parce qu’il n’a besoin que d’un verdict ; l’assistant collecte tout pour que votre formulaire puisse lister chaque problème à la fois.

​

Avant d’écrire une règle : ce groupe est-il valide ?

import {
  checkCurveRuleGroupWritable,
  LaunchpadCurveRuleField,
  LaunchpadCurveRuleOp,
} from "@raydium-io/raydium-sdk-v2";

const constraints = [
  { field: LaunchpadCurveRuleField.Supply, op: LaunchpadCurveRuleOp.Eq, value: new BN("1000000000000000") },
  { field: LaunchpadCurveRuleField.TotalFundRaisingB, op: LaunchpadCurveRuleOp.Gte, value: new BN("50000000000") },
  { field: LaunchpadCurveRuleField.TotalFundRaisingB, op: LaunchpadCurveRuleOp.Lte, value: new BN("200000000000") },
];

const writable = checkCurveRuleGroupWritable({
  groupId: 0,
  constraints,
  curveType: globalConfig.curveType,
  // les ids que la règle détient déjà, donc remplacer un groupe n'est pas confondu avec en ajouter un
  existingGroupIds: existingRule?.groups.map((g) => g.groupId) ?? [],
});

// chaque erreur porte le code d'erreur du programme avec lequel la transaction aurait échoué
if (!writable.ok) console.log(writable.errors);

​

Testez d’abord sur devnet

1. Créez une config de plateforme et une règle sur devnet, et écrivez les mêmes groupes que vous avez l’intention d’expédier.
2. Exécutez chaque forme de lancement que votre UI peut produire à travers checkLaunchAgainstCurveRule, et confirmez que les verdicts sont ceux que vous attendez — à la fois les formes qui devraient passer et les formes qui devraient être rejetées.
3. Activez restrict_curve_param, puis lancez réellement un token qui devrait passer et un qui devrait être rejeté. Le second devrait échouer avec CurveParamNotMatchPlatformRule (6025), pas avec NotEnoughRemainingAccounts (6018) — ce dernier signifie que votre builder n’ajoute pas le PDA de règle et la vérification n’est pas réellement exercée.
4. Seulement alors répétez sur mainnet, dans le même ordre.

​

Exploiter une règle

​

Le gestionnaire délégué

​

Le loyer suit le contenu

​

Ordre de déploiement

1. Répétez la séquence entière sur devnet — voir Testez d’abord sur devnet.
2. Créez le compte de règle et écrivez ses groupes. Rien ne change encore — avec restrict_curve_param toujours à 0, le programme ne les lit pas.
3. Vérifiez la règle hors-chain avec checkLaunchAgainstCurveRule : pour chaque forme de lancement que votre UI peut produire, confirmez qu’un groupe l’accepte.
4. Définissez restrict_curve_param à 1. À partir de ce moment, les lancements de vos créateurs sont vérifiés.
5. Pour revenir en arrière, définissez-le à 0 à nouveau. Le compte de règle est laissé intact.

​

Coût au moment du lancement

​

Où aller ensuite

• products/launchlab/platform-config — les champs PlatformConfig qui gating et délèguent les règles.
• products/launchlab/global-config — les planchers du protocole qu’une règle affine.
• products/launchlab/instructions — les quatre instructions de règle et leurs comptes.
• products/launchlab/accounts — PlatformCurveRule dans l’inventaire des comptes.
• sdk-api/typescript-sdk — la surface du SDK où vivent les deux assistants de vérification.
• reference/changelog/2026-08-31-launchlab-platform-curve-rules — ce qui a remplacé la liste blanche de paramètres de courbe, et ce que les décodeurs doivent changer.

• raydium-launch/programs/launchpad/src/states/platform_curve_rule.rs — PlatformCurveRule, CurveRuleGroup, ParamConstraint, les espaces d’id de champ et d’opérateur, et CurveRuleContext::value_of.
• raydium-launch/programs/launchpad/src/utils/platform_curve_rule.rs — la vérification au moment du lancement.
• raydium-launch/programs/launchpad/src/instructions/platform/ — create, update, remove, et close_platform_curve_rule.