LaunchLab GlobalConfig

Comptes de configuration au niveau du protocole qui encadrent chaque lancement LaunchLab — taux de frais, minimums de fourniture, plafonds de taux de verrouillage, portefeuilles de migration qui contrôlent la graduation, et schéma d’indexation par courbe.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.

Voir la version anglaise →

GlobalConfig est le compte de configuration au niveau du protocole. Il peut y en avoir plusieurs — identifiés par (curve_type, index) — et chaque lancement en choisit exactement un au moment de l’Initialize. Les valeurs du GlobalConfig choisi deviennent alors des limites incontournables pour les paramètres de ce lancement. Pour la personnalisation au niveau de la plateforme (taux de frais par plateforme, formes de courbes autorisées, répartitions NFT à la graduation), consultez products/launchlab/platform-config.

​

Qu’est-ce que c’est

Un GlobalConfig est un PDA singleton-par-(curve_type, index) qui fixe les règles au niveau du protocole que tout lancement doit respecter :

• Le type de courbe de liaison autorisé (curve_type).
• Le taux de frais commerciaux que la courbe prélève sur chaque achat et vente.
• Les frais de migration prélevés à la graduation.
• Des planchers sur la fourniture, le taux de verrouillage, le taux de vente et le taux de migration.
• Le mint de cotation (généralement SOL enrobé ou USDC) — l’actif avec lequel les utilisateurs achètent.
• Trois portefeuilles au niveau du protocole : le propriétaire des frais de protocole, le propriétaire des frais de migration, et les deux portefeuilles de contrôle de migration qui autorisent la graduation vers AMM v4 / CPMM.
• Un drapeau optionnel (requires_platform_auth) qui limite les plates-formes pouvant utiliser cette configuration.

Les comptes GlobalConfig sont créés et mis à jour par l’administrateur du programme LaunchLab (la clé publique d’administrateur codée en dur partagée entre les programmes Raydium basés sur Anchor — voir reference/program-addresses).

​

Disposition

// states/config.rs
pub const GLOBAL_CONFIG_SEED: &str = "global_config";

#[account]
pub struct GlobalConfig {
    pub epoch:                   u64,         // recent_epoch tracker
    pub curve_type:              u8,          // 0 = ConstantProduct, 1 = FixedPrice, 2 = LinearPrice
    pub index:                   u16,         // discriminator within a curve_type
    pub migrate_fee:             u64,         // SOL paid on graduation
    pub trade_fee_rate:          u64,         // 1/1_000_000 of volume
    pub max_share_fee_rate:      u64,         // 100 bps cap on platform share fee
    pub min_base_supply:         u64,         // floor on Initialize supply (no decimals)
    pub max_lock_rate:           u64,         // ceiling on vesting locked / supply
    pub min_base_sell_rate:      u64,         // floor on base_supply_graduation / supply
    pub min_base_migrate_rate:   u64,         // floor on tokens that seed the post-graduation pool
    pub min_quote_fund_raising:  u64,         // floor on quote_reserve_target (with decimals)
    pub quote_mint:              Pubkey,
    pub protocol_fee_owner:      Pubkey,      // claims protocol fees via CollectFee
    pub migrate_fee_owner:       Pubkey,      // claims migration fees via CollectMigrateFee
    pub migrate_to_amm_wallet:   Pubkey,      // can sign MigrateToAmm
    pub migrate_to_cpswap_wallet:Pubkey,      // can sign MigrateToCpswap
    pub requires_platform_auth:  u8,          // 0/1 flag
    pub padding_alignment:       [u8; 7],
    pub padding:                 [u64; 15],
}

Dérivation du PDA :

const [globalConfig] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("global_config"),
    Buffer.from(quoteMint.toBytes()),
    Buffer.from([curveType]),
    u16ToBytes(index),
  ],
  LAUNCHLAB_PROGRAM_ID,
);

(Vérifiez l’ordre exact des seeds sur le compte en chaîne avant de signer — l’instruction create_config du programme est la source de vérité.)

​

Sémantique des champs

​

curve_type et index

Ensemble, ces champs identifient un GlobalConfig de manière unique. Il y a un GlobalConfig par paire (curve_type, index) :

• curve_type = 0 — Courbe de réserve virtuelle à produit constant. La plus utilisée par défaut.
• curve_type = 1 — Courbe à prix fixe.
• curve_type = 2 — Courbe à prix linéaire.

index est un u16 qui permet à l’administrateur de publier plusieurs configurations par type de courbe (par exemple, une avec des frais plus serrés, une avec un minimum de levée de fonds plus élevé). À l’Initialize, le lancement fournit une paire (curve_type, index) et le programme charge le GlobalConfig correspondant.

​

Frais

• trade_fee_rate — dénominé en 1/1_000_000 du volume d’échange. Appliqué à chaque achat et vente sur la courbe. Le protocol_fee_owner réclame sa part via CollectFee.
• migrate_fee — frais fixes en lamports (ou unités de cotation, selon la configuration) prélevés une fois à la graduation. Réclamés par migrate_fee_owner via CollectMigrateFee.
• max_share_fee_rate — initialisé à 10_000 (100 bps). Limite le taux de frais de partage de la plateforme provenant du PlatformConfig contraignant (voir platform-config). Le programme impose que trade_fee_rate + max_share_fee_rate < RATE_DENOMINATOR_VALUE.

​

Planchers de fourniture et de taux

Ces planchers limitent les paramètres de forme de courbe qu’un lancement peut choisir à l’Initialize. Si les CurveParams du créateur les violent, l’Initialize échoue avec InvalidInput.

• min_base_supply — la supply minimale (sans décimales) que la courbe peut déclarer. La valeur par défaut est 10_000_000.
• max_lock_rate — dénominé en 1/1_000_000 ; valeur par défaut 300_000 (30%). Limite le verrouillage via total_locked_amount <= supply * max_lock_rate / 1_000_000.
• min_base_sell_rate — dénominé en 1/1_000_000 ; valeur par défaut 200_000 (20%). Limite base_supply_graduation / supply par le bas.
• min_base_migrate_rate — dénominé en 1/1_000_000 ; valeur par défaut 200_000 (20%). Limite le nombre de tokens restants pour ensemencer le pool post-graduation.
• min_quote_fund_raising — minimum quote_reserve_target qu’un lancement peut déclarer (avec décimales). La valeur par défaut est 30_000_000_000 unités du mint de cotation.

​

Mint de cotation et portefeuilles de protocole

• quote_mint — l’actif avec lequel les utilisateurs achètent. La plupart des lancements utilisent le SOL enrobé (So111…112) ou l’USDC (EPjF…Dt1v). Un GlobalConfig est lié à un mint de cotation ; les lancements qui ont besoin d’une cible de cotation différente ciblent un (curve_type, index) différent.
• protocol_fee_owner — clé publique qui signe CollectFee et réclame les frais de protocole accumulés sur chaque lancement lié à cette configuration. Stockée en chaîne ; l’administrateur peut la faire tourner via UpdateConfig.
• migrate_fee_owner — clé publique qui signe CollectMigrateFee.

​

Portefeuilles de migration

Les deux chemins de graduation nécessitent des signataires différents :

• migrate_to_amm_wallet — doit signer MigrateToAmm. Utilisé pour les lancements dont migrate_type = 0 (graduation vers AMM v4 + OpenBook).
• migrate_to_cpswap_wallet — doit signer MigrateToCpswap. Utilisé pour migrate_type = 1 (graduation vers CPMM). Les lancements Token-2022 empruntent toujours ce chemin.

Ils sont généralement gérés par la crank de graduation opérée par Raydium, de sorte que la graduation se déroule peu après que la courbe atteigne le seuil plutôt que d’attendre que le créateur l’appelle.

​

requires_platform_auth

Un drapeau u8 (0 = n’importe qui peut utiliser cette configuration ; non-zéro = seules les plates-formes avec un PDA PlatformGlobalAccess valide peuvent lancer contre elle). Lorsqu’il est défini, chaque Initialize contre ce GlobalConfig doit inclure un compte PlatformGlobalAccess correspondant prouvant que la plateforme a été pré-autorisée via CreatePlatformGlobalAccess (une instruction réservée à l’administrateur). Voir platform-config pour la mécanique côté plateforme.

​

Valeurs par défaut à l’initialisation

Quand CreateConfig est appelé, le programme initialise de nombreux champs avec des valeurs par défaut codées en dur :

self.max_share_fee_rate     = 10_000;                  // 100 bps
self.min_base_supply        = 10_000_000;              // no decimals
self.max_lock_rate          = 300_000;                 // 30%
self.min_base_migrate_rate  = 200_000;                 // 20%
self.min_base_sell_rate     = 200_000;                 // 20%
self.min_quote_fund_raising = 30_000_000_000;
self.requires_platform_auth = 0;

L’administrateur définit explicitement curve_type, index, migrate_fee, trade_fee_rate, quote_mint et les quatre clés publiques du portefeuille au moment de la création ; les valeurs suivantes peuvent être ajustées via UpdateConfig.

​

Comment un lancement choisit un GlobalConfig

À l’Initialize, le créateur transmet :

• (curve_type, index) pour sélectionner quel PDA GlobalConfig charger.
• CurveParams décrivant la forme de la courbe (supply, total_base_sell, total_quote_fund_raising, migrate_type).
• VestingParams décrivant la fourniture verrouillée.
• MintParams pour le mint de base.

Le programme impose que :

• curve_type correspond à global_config.curve_type.
• supply >= global_config.min_base_supply.
• total_locked_amount <= supply * max_lock_rate / 1_000_000.
• total_base_sell >= supply * min_base_sell_rate / 1_000_000.
• (supply − total_base_sell − total_locked_amount) >= supply * min_base_migrate_rate / 1_000_000 — c’est-à-dire suffisamment de tokens restants pour ensemencer le pool post-graduation.
• total_quote_fund_raising >= min_quote_fund_raising.
• Si requires_platform_auth != 0, un PDA PlatformGlobalAccess valide est inclus.

Après l’Initialize, le PoolState du lancement stocke la clé publique global_config directement, de sorte que la liaison est permanente.

​

Chemin de mise à jour

UpdateConfig est réservé à l’administrateur et prend une paire (param: u8, value: u64). Chaque valeur param sélectionne quel champ muter :

param	Champ modifié
0	migrate_fee
1	trade_fee_rate
2	max_share_fee_rate
3	min_base_supply
4	max_lock_rate
5	min_base_sell_rate
6	min_base_migrate_rate
7	min_quote_fund_raising

Les rotations de portefeuille (protocol_fee_owner, migrate_fee_owner, migrate_to_amm_wallet, migrate_to_cpswap_wallet) prennent une forme d’argument Pubkey séparé ; consultez la source update_config pour la table de dispatch exacte avant de composer une transaction administrative.

requires_platform_auth est basculé via set_requires_platform_auth(bool).

​

Lire un GlobalConfig depuis un client

import { Raydium } from "@raydium-io/raydium-sdk-v2";

// Fetch by PDA derivation:
const [configPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("global_config"),
    quoteMint.toBytes(),
    Buffer.from([curveType]),
    u16ToBytes(index),
  ],
  LAUNCHLAB_PROGRAM_ID,
);

const config = await raydium.launchpad.getGlobalConfig(configPda);
console.log(config.tradeFeeRate, config.minQuoteFundRaising);

Pour une interface utilisateur listant toutes les configurations disponibles, parcourez l’assistant getAllGlobalConfigs du SDK ou interrogez le point de terminaison de l’API LaunchLab qui les reflète ; le nombre de comptes en chaîne est petit (quelques unités en pratique).

​

Pointeurs

• products/launchlab/platform-config — superposition par plateforme qui contraint davantage la forme de la courbe.
• products/launchlab/accounts — graphe de compte complet pour un lancement.
• products/launchlab/instructions — instructions Initialize et de mise à jour.
• reference/program-addresses — clé publique d’administrateur, ID du programme, autorités partagées.

Sources :

• raydium-launch/programs/launchpad/src/states/config.rs — struct GlobalConfig et initialize.
• raydium-launch/programs/launchpad/src/lib.rs — create_config, update_config.