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.

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

Englische Version ansehen →

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.

​

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:

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

// 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:

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).
• 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 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.

#[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:

// 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

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 — Protokoll-seitige Regeln, die ein Launch erfüllen muss.
• products/launchlab/vesting — platform_vesting_scale-Mechanik.
• products/launchlab/creator-fees — Fee-Key NFT, Burn & Earn.
• 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.