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

> Platform-spezifische Konfiguration, die Branding, Gebührenaufteilungen, NFT-Migrationsanteile, Vesting-Zuweisung und die Whitelist zulässiger Kurvenstapel für jeden über diese Plattform geleiteten Launch anpasst.

<Info>
  **Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.**

  [Englische Version ansehen →](/products/launchlab/platform-config)
</Info>

<Info>
  `PlatformConfig` ist die **Plattform-Ebenen**-Überlagerung auf `[GlobalConfig](/de/products/launchlab/global-config)`. Während `GlobalConfig` die protokollweiten Regeln definiert („Handelsgebühr beträgt 1 %, das Angebot muss mindestens 10 M betragen, nur diese Wallet kann graduiert werden"), ist `PlatformConfig` das, was jede Launch-Plattform — pump.fun, Raydiums eigene UI, Drittanbieter-Launchpads — verwendet, um ihre Gebühr hinzuzufügen, ihren Anteil am LP nach der Graduierung zu beanspruchen, einzuschränken, welche Kurvenstapel ihre Launches wählen können, und ihr Branding (Name, Website, Bild) on-chain anzuzeigen.
</Info>

## Was es ist

Ein `PlatformConfig`-Konto verwaltet vier übergreifende Anliegen einer Plattform:

1. **Branding** — Name, Website, Bildlink, alles inline gespeichert, damit jeder Explorer oder Aggregator die Plattform anzeigen kann, die einen Token gestartet hat.
2. **Plattformgebühr** — eine zusätzliche Handelsgebühr (`fee_rate`) auf der Protokoll-`trade_fee_rate`. Wird auf die `platform_fee_wallet` der Plattform angerechnet. Gedeckelt bei 100 bps durch `GlobalConfig.max_share_fee_rate`.
3. **NFT-Migrationsaufteilung** — drei Ganzzahlen (`platform_scale`, `creator_scale`, `burn_scale`), die sich zu `RATE_DENOMINATOR_VALUE = 1_000_000` summieren und das LP nach der Graduierung in einen an die Platform-NFT-Wallet geprägten Anteil, einen an die Creator-NFT-Wallet und einen verbrannten Anteil (Burn & Earn) aufteilen. Nur sinnvoll, wenn die Graduierung CPMM als Ziel hat (`migrate_type = 1`).
4. **Kurvenparameter-Whitelist** — ein `Vec<PlatformCurveParam>`, das genau auflistet, welche `(supply, total_base_sell, total_quote_fund_raising, migrate_type, migrate_cpmm_fee_on, vesting_params...)`-Kombinationen auf dieser Plattform zulässig sind. Wenn der Vektor leer ist oder alle Einträge ungültig sind, ist **jede** Kombination zulässig; andernfalls müssen Launches genau mit einem der Einträge übereinstimmen.

PDA-Ableitung:

```ts theme={null}
const [platformConfigPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("platform_config"),
    platformAdmin.toBuffer(),       // platform's owning pubkey
  ],
  LAUNCHLAB_PROGRAM_ID,
);
```

(Siehe `create_platform_config` in der Quelle für die kanonische Seed-Liste.)

## Layout

```rust theme={null}
// states/platform_config.rs
pub const PLATFORM_CONFIG_SEED: &str = "platform_config";
pub const NAME_SIZE: usize = 64;
pub const WEB_SIZE:  usize = 256;
pub const IMG_SIZE:  usize = 256;
pub const MAX_CREATOR_FEE_RATE: u64 = 5000;       // 50 bps (denominator 1_000_000)
pub const MAX_TRANSFER_FEE_RATE: u16 = 500;       // 5%   (denominator 10_000)
pub const MAX_CURVE_PARAMS: usize = 10;

#[account]
pub struct PlatformConfig {
    pub epoch:                       u64,
    pub platform_fee_wallet:         Pubkey,            // signs ClaimPlatformFee
    pub platform_nft_wallet:         Pubkey,            // receives the platform NFT slice at CPMM graduation
    pub platform_scale:              u64,               // share of LP minted to platform NFT
    pub creator_scale:               u64,               // share of LP minted to creator NFT
    pub burn_scale:                  u64,               // share of LP burned via Burn & Earn
    pub fee_rate:                    u64,               // platform's trade fee (1/1_000_000)
    pub name:                        [u8; 64],          // utf-8 padded with zeros
    pub web:                         [u8; 256],
    pub img:                         [u8; 256],
    pub cpswap_config:               Pubkey,            // CPMM AmmConfig that the post-grad pool will bind to
    pub creator_fee_rate:            u64,               // creator-side fee taken pre-graduation
    pub transfer_fee_extension_auth: Pubkey,            // for Token-2022 launches: who inherits transfer-fee authorities post-graduation
    pub platform_vesting_wallet:     Pubkey,
    pub platform_vesting_scale:      u64,               // platform's slice of total_locked_amount
    pub platform_cp_creator:         Pubkey,            // optional creator-of-record on the post-graduation CPMM pool
    pub padding:                     [u8; 108],
    pub curve_params:                Vec<PlatformCurveParam>, // whitelist of permitted curve shapes
}
```

`platform_scale + creator_scale + burn_scale` muss `1_000_000` entsprechen (validiert durch `MigrateNftInfo::check`). Häufige Aufteilungen in der Produktion:

* `(0, 100_000, 900_000)` — 90 % LP verbrannt, 10 % an Creator. Standard-Pump-Style-Fair-Launch.
* `(50_000, 100_000, 850_000)` — kleiner Platform-Anteil (5 %), 10 % Creator, 85 % verbrannt.
* `(0, 0, 1_000_000)` — vollständig verbrannt, keine NFT-Prägung. Strikt „Keine-Insider"-Launches.

## Branding-Felder

`name`, `web` und `img` sind Inline-Byte-Arrays, die mit Nullen bis zu ihren Größenkonstanten aufgefüllt sind. Um sie als Strings zu lesen, schneiden Sie bis zum ersten `\0`:

```ts theme={null}
function readString(bytes: Uint8Array): string {
  const end = bytes.indexOf(0);
  return Buffer.from(end === -1 ? bytes : bytes.subarray(0, end)).toString("utf-8");
}
```

Die Konstanten sind absichtlich großzügig (`name: 64`, `web: 256`, `img: 256`), damit Plattformen genug Metadaten für Explorer und Aggregatoren enthalten können, ohne Off-Chain-Speicher zu nutzen. Alles, was diese Größen überschreitet, führt zu einem Revert bei `CreatePlatformConfig` mit `InvalidInput`.

## Gebühren-Mechanik

Ein Swap auf einer Kurve, die an eine `PlatformConfig` gebunden ist, berechnet drei gestaffelte Gebühren:

```
trade_fee     = amount_in × global_config.trade_fee_rate    / 1_000_000
platform_fee  = amount_in × platform_config.fee_rate        / 1_000_000
creator_fee   = amount_in × platform_config.creator_fee_rate / 1_000_000

amount_after_fee = amount_in − trade_fee − platform_fee − creator_fee
```

* `trade_fee` wird auf den `protocol_fee_owner` des Protokolls angerechnet (eingefordert über `CollectFee`).
* `platform_fee` wird auf einen Platform-spezifischen Tresor angerechnet (eingefordert über `ClaimPlatformFee` oder `ClaimPlatformFeeFromVault`; siehe [`instructions`](/de/products/launchlab/instructions)).
* `creator_fee` wird auf einen Creator-spezifischen Tresor angerechnet, der mit der Pubkey des Creators + Quote-Mint verschlüsselt ist (eingefordert über `ClaimCreatorFee`).

`creator_fee_rate` ist auf `MAX_CREATOR_FEE_RATE = 5000` (50 bps) gedeckelt. `fee_rate` (die Platform-Gebühr) ist auf `10000` (100 bps) durch `GlobalConfig.max_share_fee_rate` gedeckelt.

## NFT-Migrationsaufteilung (nur CPMM)

Wenn ein Launch zu CPMM graduiert (`migrate_type = 1`, unterzeichnet von `migrate_to_cpswap_wallet`), teilt die Migrations-Instruktion die vom `CPMM::InitializeWithPermission` geprägten LP-Token drei Wege:

```
lp_to_platform = lp_total × platform_scale / 1_000_000   → platform_nft_wallet
lp_to_creator  = lp_total × creator_scale  / 1_000_000   → creator NFT (Fee Key)
lp_to_burn     = lp_total × burn_scale     / 1_000_000   → Burn & Earn lock program
```

Die Platform- und Creator-Anteile werden als **NFTs** vom LP-Lock-Programm (`LockrWmn6K5twhz3y9w1dQERbmgSaRkfnTeTKbpofwE`) umhüllt — der Inhaber des NFT ist berechtigt, anfallende CPMM-Gebühren unbegrenzt einzufordern, ohne die zugrunde liegende Liquidität abheben zu können. Siehe [`products/launchlab/creator-fees`](/de/products/launchlab/creator-fees) für den Fee-Key-Fluss nach der Graduierung.

Der Burn-Anteil wird mit `is_burn = true` an das Lock-Programm gesendet, sodass die LP-Token dauerhaft unzugänglich sind — sie sichern den Preisboden des Pools, ohne jemals Gebühren an jemanden zurückzuzahlen.

Wenn `migrate_type = 0` (graduiert zu AMM v4), werden die NFT-Split-Felder ignoriert und das gesamte LP wird gemäß einem separaten AMM-v4-seitigen Fluss gesperrt/verbrannt.

## Kurvenparameter-Whitelist

`curve_params: Vec<PlatformCurveParam>` ist der Mechanismus der Plattform, um einzuschränken, welche Kurvenstapel ihre Launches wählen können. Wenn der Vektor nicht leer ist und mindestens ein Eintrag gültig ist, erzwingt das Programm bei `Initialize`, dass die Parameter des Launch mit mindestens einem Eintrag genau übereinstimmen.

```rust theme={null}
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct PlatformCurveParam {
    pub epoch:                u64,
    pub index:                u8,           // ordinal within this platform's whitelist
    pub global_config:        Pubkey,       // which GlobalConfig this entry applies to
    pub bonding_curve_param:  BondingCurveParam,
    pub padding:              [u64; 50],
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct BondingCurveParam {
    pub migrate_type:               u8,    // 0 = AMM v4, 1 = CPMM. u8::MAX = wildcard
    pub migrate_cpmm_fee_on:        u8,    // 0 = quote-only, 1 = both. u8::MAX = wildcard
    pub supply:                     u64,   // 0 = wildcard
    pub total_base_sell:            u64,   // 0 = wildcard
    pub total_quote_fund_raising:   u64,   // 0 = wildcard
    pub total_locked_amount:        u64,   // u64::MAX = wildcard
    pub cliff_period:               u64,   // u64::MAX = wildcard
    pub unlock_period:              u64,   // u64::MAX = wildcard
}
```

Jedes Feld hat einen Sentinel-Wert, der **Wildcard** bedeutet (jeder Wert passt): `u64::MAX` für die `u64`-Felder, `u8::MAX` für die `u8`-Felder, `0` für die Supply-/Sell-/Fundraising-Felder. Ein `BondingCurveParam` mit allen Sentinels ist „Alles erlauben" — equivalent zum Verhalten der leeren Whitelist.

Der Matching-Algorithmus bei `Initialize`:

1. Filtern Sie `curve_params` zu Einträgen, deren `global_config` dem `GlobalConfig` des Launch entspricht.
2. Wenn die gefilterte Liste leer ist, erlauben Sie beliebige Parameter (die Plattform hat für diese `GlobalConfig` nichts auf die Whitelist gesetzt).
3. Wenn jeder Eintrag in der gefilterten Liste `all_is_invalid()` hat (jedes Feld ist das Wildcard), erlauben Sie beliebige Parameter.
4. Iterieren Sie andernfalls Einträge; für jeden Eintrag überprüfen Sie die Parameter des Launch gegen jedes Nicht-Wildcard-Feld. Wenn alle Nicht-Wildcard-Felder übereinstimmen, akzeptieren und zurückgeben.
5. Wenn kein Eintrag übereinstimmte, Revert mit `InvalidInput`.

Dies ermöglicht einer Plattform zu sagen „wir erlauben nur die Standard-1B-Supply-/800M-verkauft-/30k-USDC-Raise-/kein-Vesting-Form", indem sie einen einzelnen Eintrag mit konkreten Werten für diese vier Felder und Wildcards überall sonst schreibt. Oder eine strengere Plattform könnte drei oder vier diskrete Formen aufzählen, eine pro unterstützter Launch-Stufe.

`MAX_CURVE_PARAMS = 10` deckelt die Whitelist-Größe.

## `PlatformGlobalAccess` — Eine Plattform autorisieren

Wenn ein `GlobalConfig` `requires_platform_auth = 1` hat, muss jedes `Initialize` dagegen einen `PlatformGlobalAccess`-PDA enthalten, der beweist, dass die Plattform vorautorisiert wurde:

```rust theme={null}
// states/platform_global_access.rs
pub const PLATFORM_GLOBAL_ACCESS_SEED: &str = "platform_global_access";

#[account]
pub struct PlatformGlobalAccess {
    pub bump:            u8,
    pub global_config:   Pubkey,
    pub platform_config: Pubkey,
    pub padding:         [u64; 8],
}
```

PDA-Seeds: `[b"platform_global_access", global_config, platform_config]`.

Der Protokoll-Admin erstellt einen pro `(GlobalConfig, PlatformConfig)`-Paar über `CreatePlatformGlobalAccess` und widerruft ihn über `ClosePlatformGlobalAccess`. Ohne dieses Konto kann ein Launch nicht von dieser gated Platform aus an diesen `GlobalConfig` gebunden werden.

## Read-Pfad

```ts theme={null}
const platformConfig = await raydium.launchpad.getPlatformConfig(platformConfigPda);

console.log("Platform:", readString(platformConfig.name));
console.log("Fee rate:", platformConfig.feeRate, "(/1M)");
console.log("NFT split:",
  platformConfig.platformScale,
  platformConfig.creatorScale,
  platformConfig.burnScale,
);
console.log("Curve whitelist size:", platformConfig.curveParams.length);
```

Für eine UI, die „von wo aus wurde dieser Token gestartet", zeigt `PoolState.platform_config` direkt auf den ursprünglichen `PlatformConfig` — rufen Sie ihn einmal auf und cachen Sie das Branding.

## Update-Pfad

| Instruktion                 | Wer unterzeichnet          | Was ändert sich                                                                                                                                                                          |
| --------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CreatePlatformConfig`      | Plattform-Admin (einmalig) | Initialisiert das Konto mit `PlatformParams`.                                                                                                                                            |
| `UpdatePlatformConfig`      | Plattform-Admin            | Generischer Dispatch gekeymed nach `param: u8`; mutiert ein Feld pro Aufruf. Branding-Felder, Gebührensätze, Vesting-Wallet und die verschiedenen Wallets sind alle durch diese setzbar. |
| `UpdatePlatformCurveParam`  | Plattform-Admin            | Einen `PlatformCurveParam`-Eintrag nach `(global_config, index)` hinzufügen oder ersetzen.                                                                                               |
| `RemovePlatformCurveParam`  | Plattform-Admin            | Einen Eintrag löschen (setzt ihn auf all-sentinel = wildcard).                                                                                                                           |
| `ClaimPlatformFee`          | `platform_fee_wallet`      | Sweep die Platform-Gebühr pro Pool aus `PoolState.quote_vault`.                                                                                                                          |
| `ClaimPlatformFeeFromVault` | `platform_fee_wallet`      | Sweep den Platform-spezifischen Gebühren-Tresor (PDA bei `[platform_config, quote_mint]`).                                                                                               |

Wallet-Rotationen (`platform_fee_wallet`, `platform_nft_wallet`, `platform_vesting_wallet`, `platform_cp_creator`, `transfer_fee_extension_auth`, `cpswap_config`) erfolgen alle über `UpdatePlatformConfig`. Lesen Sie die `update_platform_config`-Dispatch-Tabelle der Quelle für die genauen `param`-Codes.

## Häufige Fallstricke

* **Whitelist-Sentinels falsch gesetzt.** Ein `BondingCurveParam` mit `total_locked_amount = 0` ist *nicht* ein Wildcard — es passt auf Launches, die sich explizit gegen Vesting entscheiden. Das Wildcard für dieses Feld ist `u64::MAX`. Der gleiche Fallstrick existiert für `cliff_period` und `unlock_period`. Nutzen Sie `clear()` (das das Programm offenlegt), um Sentinels korrekt zu setzen.
* **NFT-Split-Rundung.** Die drei Scales müssen sich zu genau `1_000_000` summieren. Off-by-One-Fehler bei `CreatePlatformConfig` führen zu Revert; Off-by-One zur Laufzeit würde eine extra LP-Einheit prägen oder verbrennen, was die strikte Gleichheitsprüfung verhindern soll.
* **Platform-Vesting-Doppelzuweisung.** Wenn `platform_vesting_scale > 0`, muss die Plattform `CreatePlatformVestingAccount` einmal aufrufen, nachdem das Fundraising des Launch endet; wenn sie das vergisst, bleibt dieser Anteil unzugewiesen und inaktiv auf Dauer (das `total_locked_amount`-Budget des Launch wird verbraucht, aber die Plattform fordert ihn nie ein).
* **`platform_cp_creator`-Mehrdeutigkeit.** Wenn auf `Pubkey::default()` gesetzt, wird der Launch-Creator als `pool_creator` des Post-Graduierungs-CPMM-Pools aufgezeichnet; wenn auf einen echten Schlüssel gesetzt, wird dieser Schlüssel stattdessen aufgezeichnet. Dies beeinflusst, wer später `CPMM::CollectCreatorFee` aufrufen kann. Entscheiden Sie sich bei der Erstellung der Platform-Config, welches Modell Sie mögen.

## Zeiger

* [`products/launchlab/global-config`](/de/products/launchlab/global-config) — Protokoll-seitige Regeln, die ein Launch erfüllen muss.
* [`products/launchlab/vesting`](/de/products/launchlab/vesting) — `platform_vesting_scale`-Mechanik.
* [`products/launchlab/creator-fees`](/de/products/launchlab/creator-fees) — Fee-Key NFT, Burn & Earn.
* [`products/launchlab/platforms`](/de/products/launchlab/platforms) — Plattform-Integrator-How-To.

Quellen:

* `raydium-launch/programs/launchpad/src/states/platform_config.rs` — `PlatformConfig`, `PlatformParams`, `MigrateNftInfo`, `PlatformCurveParam`, `BondingCurveParam`, `is_valid_curve_param`.
* `raydium-launch/programs/launchpad/src/states/platform_global_access.rs` — `PlatformGlobalAccess`.
* `raydium-launch/programs/launchpad/src/lib.rs` — `create_platform_config`, `update_platform_config`, `update_platform_curve_param`, `remove_platform_curve_param`, `create_platform_global_access`, `close_platform_global_access`, `claim_platform_fee`, `claim_platform_fee_from_vault`.