> ## 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.

# 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.

<Info>
  **Cette page est traduite automatiquement par IA. La version anglaise fait foi.**

  [Voir la version anglaise →](/products/launchlab/global-config)
</Info>

<Info>
  `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`](/fr/products/launchlab/platform-config).
</Info>

## 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`](/fr/reference/program-addresses)).

## Disposition

```rust theme={null}
// 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 :

```ts theme={null}
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`](/fr/products/launchlab/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`](/fr/products/launchlab/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 :

```rust theme={null}
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

```ts theme={null}
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`](/fr/products/launchlab/platform-config) — superposition par plateforme qui contraint davantage la forme de la courbe.
* [`products/launchlab/accounts`](/fr/products/launchlab/accounts) — graphe de compte complet pour un lancement.
* [`products/launchlab/instructions`](/fr/products/launchlab/instructions) — instructions `Initialize` et de mise à jour.
* [`reference/program-addresses`](/fr/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`.