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

# Aturan kurva LaunchLab

> Bagaimana platform membatasi parameter peluncuran yang dapat dipilih kreator: periksa grup, model kendala (field, op, value), dan sembilan playbook — tingkat tepat, pita nilai, batas valuasi kelulusan, lantai migrasi, gating tipe token, dan promosi terikat waktu.

<Info>
  **Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.**

  [Lihat versi bahasa Inggris →](/products/launchlab/curve-rules)
</Info>

<Info>
  Sebuah **curve rule** adalah jawaban platform terhadap "peluncuran mana yang bersedia saya host?". [`GlobalConfig`](/id/products/launchlab/global-config) menetapkan lantai protokol — suplai minimal 10M, minimal 20% suplai terjual di kurva, dan seterusnya — dan lantai tersebut sengaja lebar sehingga setiap jenis platform sesuai di bawahnya. Curve rule adalah tempat platform Anda mempersempit mereka ke bentuk yang benar-benar didukung produk Anda.

  Aturan hidup di akun `PlatformCurveRule` mereka sendiri, satu per pasangan (platform, [`GlobalConfig`](/id/products/launchlab/global-config)). Mereka hanya dapat mempersempit apa yang sudah diizinkan konfigurasi; aturan tidak pernah dapat memperluas batas protokol.
</Info>

## Model mental

Tiga tingkat, dari luar ke dalam:

```
GlobalConfig       lantai protokol      "supply >= 10M, sell rate >= 20%, ..."
  └─ PlatformCurveRule   aturan Anda     "dan di platform saya: salah satu bentuk ini"
       └─ check group    satu bentuk     "supply = 1B AND fund raising in [80, 90] SOL"
            └─ constraint satu pemeriksaan    "(Supply, Eq, 1_000_000_000)"
```

Dua tingkat nesting adalah apa yang membuat ini ekspresif:

* **Kendala di dalam satu grup di-AND.** Semuanya harus berlaku.
* **Grup di dalam satu aturan di-OR.** Peluncuran diizinkan segera setelah memenuhi grup mana pun.

Jadi grup adalah satu *bentuk* yang diizinkan, dan aturan adalah menu bentuk yang Anda tawarkan. Aturan menampung hingga 10 grup, dan grup menampung hingga 25 kendala.

Dua kasus batas layak diingat:

| Status                                             | Arti                                                                                 |
| -------------------------------------------------- | ------------------------------------------------------------------------------------ |
| Tidak ada akun aturan, atau aturan dengan nol grup | Platform tidak membatasi parameter peluncuran untuk konfigurasi itu.                 |
| Grup dengan nol kendala                            | Grup itu cocok dengan setiap peluncuran, jadi seluruh aturan memungkinkan segalanya. |

Aturan berlaku hanya saat `PlatformConfig.restrict_curve_param` adalah `1`. Pada `0` program tidak membaca aturan sama sekali, yang juga merupakan sakelar yang Anda gunakan untuk meluncurkan aturan dan untuk memutar kembali.

## Kendala

Kendala adalah triple `(field, op, value)`. Tidak ada yang lain — tidak ada ekspresi, tidak ada nesting.

```rust theme={null}
pub struct ParamConstraint {
    pub field: u8,    // parameter peluncuran mana, lihat tabel di bawah
    pub op:    u8,    // 0 Eq, 1 Gte (min), 2 Lte (max), 3 Neq
    pub value: u128,
}
```

Sebuah **rentang adalah dua kendala** pada field yang sama di dalam satu grup: `Gte` untuk lantai dan `Lte` untuk batas. Pasangan `(field, op)` yang sama tidak boleh muncul dua kali dalam satu grup, yang mencegah Anda menulis dua minimum yang bertentangan.

### Field

<Info>
  ID field bersifat permanen. Field baru hanya ditambahkan, jadi ID tidak pernah mengubah makna setelah akun aturan memegangnya.
</Info>

| id | Field                    | Unit        | Catatan                                                                                                      |
| -- | ------------------------ | ----------- | ------------------------------------------------------------------------------------------------------------ |
| 0  | `CurveType`              | enum        | 0 constant product, 1 fixed price, 2 linear price                                                            |
| 1  | `MigrateType`            | enum        | Peluncuran baru harus `1` (CPMM) bagaimanapun                                                                |
| 2  | `MigrateCpmmFeeOn`       | enum        | 0 quote-only, 1 kedua token                                                                                  |
| 3  | `Supply`                 | base units  | Suplai token penuh                                                                                           |
| 4  | `TotalSellA`             | base units  | Terjual di kurva. Hanya konfigurasi constant-product — lihat [Pembatasan tipe kurva](#pembatasan-tipe-kurva) |
| 5  | `TotalFundRaisingB`      | quote units | Target kelulusan                                                                                             |
| 6  | `TotalLockedAmount`      | base units  | Anggaran vesting                                                                                             |
| 7  | `CliffPeriod`            | seconds     | Tunggu sebelum pembukuan dimulai                                                                             |
| 8  | `UnlockPeriod`           | seconds     | Durasi pembukuan                                                                                             |
| 9  | `BaseTokenProgram`       | enum        | 0 SPL Token, 1 Token-2022                                                                                    |
| 10 | `TransferFeeEnabled`     | bool        | 1 ketika mint dasar membawa `TransferFeeConfig`                                                              |
| 11 | `TransferFeeBasisPoints` | 1/10 000    | 0 tanpa ekstensi                                                                                             |
| 12 | `TransferFeeMaximumFee`  | base units  | 0 tanpa ekstensi                                                                                             |
| 13 | `SellRateA`              | 1/1 000 000 | Turunan: `TotalSellA / Supply`. Hanya constant-product                                                       |
| 14 | `LockRate`               | 1/1 000 000 | Turunan: `TotalLockedAmount / Supply`                                                                        |
| 15 | `MigrateAmountA`         | base units  | Turunan: `Supply − TotalSellA − TotalLockedAmount`. Hanya constant-product                                   |
| 16 | `MigrateRateA`           | 1/1 000 000 | Turunan: `MigrateAmountA / Supply`. Hanya constant-product                                                   |
| 17 | `FundRaisingRateB`       | 1/1 000 000 | Turunan: `TotalFundRaisingB / Supply`                                                                        |
| 18 | `UnixTimestamp`          | seconds     | Waktu blok peluncuran                                                                                        |

Field turunan adalah yang membuat aturan portabel. Menentukan `Supply` dan `TotalFundRaisingB` ke angka pasti memperbaiki satu bentuk peluncuran; membatasi `FundRaisingRateB` memperbaiki *hubungan* di antara mereka dan memungkinkan kreator memilih suplai apa pun yang mempertahankannya.

<Warning>
  Field tingkat hanya dapat dibandingkan dalam satu `GlobalConfig`, karena penyebut mereka bergantung pada mint kutipan konfigurasi itu dan desimalnya. Itu bukan batasan dalam praktik: aturan dibatasi pada satu konfigurasi menurut konstruksi.
</Warning>

## Sembilan playbook

Setiap playbook di bawah adalah satu aturan. Kendala ditulis sebagai `(field, op, value)`.

### 1. Satu tingkat standar

Aturan paling sederhana, dan perilaku tepat yang ditawarkan daftar putih parameter kurva yang sudah pensiun: satu bentuk, diperbaiki.

| Grup | Kendala                                                                                             |
| ---- | --------------------------------------------------------------------------------------------------- |
| 0    | `(Supply, Eq, 1_000_000_000e6)`, `(TotalSellA, Eq, 800_000_000e6)`, `(TotalFundRaisingB, Eq, 85e9)` |

Setiap peluncuran yang menyimpang dalam salah satu dari ketiganya ditolak dengan `CurveParamNotMatchPlatformRule`.

### 2. Pita bukan angka

Alasan pita ada: kreator memilih target penggalangan dana yang Anda nyaman, tanpa Anda menghitung setiap nilai.

| Grup | Kendala                                                                                              |
| ---- | ---------------------------------------------------------------------------------------------------- |
| 0    | `(Supply, Eq, 1_000_000_000e6)`, `(TotalFundRaisingB, Gte, 50e9)`, `(TotalFundRaisingB, Lte, 200e9)` |

Satu grup, empat kendala, dan kreator memiliki koridor 50–200 SOL. Di bawah daftar putih lama ini membutuhkan satu entri per nilai yang diizinkan, dan batas sepuluh entri membuatnya tidak mungkin.

### 3. Tingkat berdampingan

Grup di-OR, jadi setiap tingkat adalah grup.

| Grup | Kendala                                                             | Tingkat |
| ---- | ------------------------------------------------------------------- | ------- |
| 0    | `(Supply, Eq, 1_000_000_000e6)`, `(TotalFundRaisingB, Eq, 85e9)`    | Standar |
| 1    | `(Supply, Eq, 100_000_000e6)`, `(TotalFundRaisingB, Eq, 30e9)`      | Kecil   |
| 2    | `(Supply, Eq, 10_000_000_000e6)`, `(TotalFundRaisingB, Gte, 500e9)` | Paus    |

Urutan penting untuk komputasi, bukan semantik: evaluasi berhenti di grup pertama yang cocok, jadi letakkan tingkat yang paling sering digunakan terlebih dahulu.

### 4. Pita valuasi kelulusan

`FundRaisingRateB` adalah `TotalFundRaisingB / Supply` dalam jutaan. Membatasinya membatasi seberapa kaya token dapat lulus terlepas dari suplai yang dipilih kreator.

| Grup | Kendala                                                               |
| ---- | --------------------------------------------------------------------- |
| 0    | `(FundRaisingRateB, Gte, 60_000)`, `(FundRaisingRateB, Lte, 120_000)` |

Dengan suplai 1e12 dan mint kutipan 9-desimal, `85e9 / 1e12 × 1e6 = 85_000` berada di dalam pita itu. Kreator yang menggandakan suplai harus kira-kira menggandakan target untuk tetap di dalamnya — itulah intinya. Dua kendala menggantikan apa yang sebaliknya akan menjadi tabel pasangan `(supply, target)`.

### 5. Lantai migrasi

`MigrateRateA` adalah bagian suplai yang benar-benar mendarat di pool CPMM saat kelulusan: `Supply − TotalSellA − TotalLockedAmount`, atas suplai. Ini adalah kedalaman pool yang lulus, dan ini adalah satu-satunya tombol protokol tanpa padanan sisi platform sebelum aturan ada.

| Grup | Kendala                        |
| ---- | ------------------------------ |
| 0    | `(MigrateRateA, Gte, 150_000)` |

Minimal 15% suplai mencapai pool. Kreator tidak dapat menjual 95% di kurva dan meninggalkan buku yang dangkal.

<Note>
  Jika parameter tidak bertambah — jumlah terkunci lebih besar dari apa yang tersisa setelah penjualan kurva — nilai turunan tidak dapat dihitung dan kendala gagal tertutup, jadi peluncuran ditolak daripada diam-diam diizinkan.
</Note>

### 6. Vesting yang benar-benar Anda paksakan

`GlobalConfig.max_lock_rate` membatasi vesting dari atas. Aturan dapat meletakkan lantai di bawahnya, dan memerlukan tebing nyata.

| Grup | Kendala                                                                                |
| ---- | -------------------------------------------------------------------------------------- |
| 0    | `(LockRate, Gte, 50_000)`, `(LockRate, Lte, 200_000)`, `(CliffPeriod, Gte, 2_592_000)` |

Antara 5% dan 20% suplai terkunci, dengan minimal tebing 30 hari. Berguna untuk platform yang pitchnya adalah "tidak ada peluncuran pembukuan instan".

### 7. Gating tipe token

`BaseTokenProgram` dan `TransferFeeEnabled` independen, yang penting: mint Token-2022 tanpa `TransferFeeConfig` melaporkan `TransferFeeEnabled = 0` sama seperti mint SPL Token.

| Maksud                                | Grup | Kendala                                                    |
| ------------------------------------- | ---- | ---------------------------------------------------------- |
| Hanya SPL Token                       | 0    | `(BaseTokenProgram, Eq, 0)`                                |
| Hanya Token-2022                      | 0    | `(BaseTokenProgram, Eq, 1)`                                |
| Token-2022, tanpa biaya transfer      | 0    | `(BaseTokenProgram, Eq, 1)`, `(TransferFeeEnabled, Eq, 0)` |
| Tanpa biaya transfer, program apa pun | 0    | `(TransferFeeEnabled, Eq, 0)`                              |

### 8. Batas biaya transfer bersyarat

Tidak ada operator "if", dan tidak ada yang diperlukan — dua grup mengekspresikan kondisi.

| Grup | Kendala                                                                                                    | Dibaca sebagai                                                                 |
| ---- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| 0    | `(TransferFeeEnabled, Eq, 0)`                                                                              | Tanpa biaya transfer: baik-baik saja                                           |
| 1    | `(TransferFeeEnabled, Eq, 1)`, `(TransferFeeBasisPoints, Lte, 100)`, `(TransferFeeMaximumFee, Gte, 1_000)` | Dengan biaya: paling banyak 1%, dan biaya maksimum yang benar-benar ditetapkan |

`TransferFeeConfig` dengan tingkat nol tidak tergelincir melalui grup 0: ekstensi ada, jadi `TransferFeeEnabled` adalah `1` dan hanya grup 1 yang dapat menerimanya.

### 9. Promosi terikat waktu, dijadwalkan di muka

`UnixTimestamp` adalah waktu blok peluncuran, jadi grup dapat membawa jendela validitasnya sendiri. Anda menulis kedua grup hari ini dan peralihan terjadi dengan sendirinya.

| Grup | Kendala                                                                 | Jendela                         |
| ---- | ----------------------------------------------------------------------- | ------------------------------- |
| 0    | `(UnixTimestamp, Lte, 1_767_225_600)`, `(TotalFundRaisingB, Gte, 30e9)` | Periode promosi: minimum 30 SOL |
| 1    | `(UnixTimestamp, Gte, 1_767_225_601)`, `(TotalFundRaisingB, Gte, 80e9)` | Sesudahnya: minimum 80 SOL      |

Tidak ada transaksi yang diperlukan di batas. Biayanya adalah dua slot grup bukan satu.

## Pembatasan tipe kurva

Empat field membaca `TotalSellA`: `TotalSellA`, `SellRateA`, `MigrateAmountA`, dan `MigrateRateA`. Pada konfigurasi constant-product kreator memasok angka itu. Pada konfigurasi fixed-price atau linear-price kurva menurunkannya sebagai gantinya, dan nilai yang dibandingkan program adalah `0`, yang akan menolak setiap peluncuran.

Daripada membiarkan Anda menulis aturan yang diam-diam memblokir konfigurasi Anda sendiri, program menolak keempat field itu pada waktu tulis pada konfigurasi non-constant-product, dengan `CurveRuleFieldNotSupportedByCurve`. Hanya konfigurasi constant-product yang ada hari ini, jadi dalam praktik Anda tidak akan bertemu kesalahan ini.

## Periksa sebelum Anda mengirim

Kedua arah pemeriksaan on-chain tersedia off-chain, jadi baik kreator maupun platform tidak perlu mempelajari aturan dengan menonton transaksi kembali.

<Info>
  **Spanduk versi.**

  * SDK: `@raydium-io/raydium-sdk-v2@0.2.42-alpha` adalah versi yang setiap demo kode lain di situs ini disematkan. Dua pembantu di bawah tiba dengan rilis SDK yang mengirimkan dukungan curve-rule; sampai saat itu, portkan dari `platform_curve_rule.rs` program atau panggil program dan baca kode kesalahan.
  * Cluster: uji di Solana `devnet` terlebih dahulu — lihat [Uji di devnet terlebih dahulu](#uji-di-devnet-terlebih-dahulu).
  * Program ID: lihat [`reference/program-addresses`](/id/reference/program-addresses)

  Kedua pembantu adalah fungsi murni. Mereka tidak menyentuh RPC, jadi aman untuk dijalankan pada setiap keystroke dalam formulir.
</Info>

### Sebelum peluncuran: apakah parameter ini akan lulus?

`checkLaunchAgainstCurveRule` mencerminkan pemeriksaan waktu peluncuran program dengan tepat, termasuk perilaku gagal tertutupnya. Jalankan di formulir peluncuran Anda dan Anda dapat menonaktifkan tombol kirim dengan alasan daripada membiarkan kreator membayar transaksi yang dikembalikan.

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

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

// pada 0 program tidak membaca aturan sama sekali, jadi tidak ada yang perlu diperiksa
if (platformConfig.restrictCurveParam !== 0) {
  const ruleId = getPdaPlatformCurveRule(programId, platformConfigId, configId).publicKey;
  const ruleAccount = await connection.getAccountInfo(ruleId);

  const result = checkLaunchAgainstCurveRule({
    // undefined ketika akun tidak ada — platform tidak menulis aturan untuk konfigurasi ini
    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,
      // hilangkan transferFee sepenuhnya ketika mint dasar tidak membawa ekstensi biaya transfer
      unixTimestamp: new BN(Math.floor(Date.now() / 1000)),
    },
  });

  if (!result.ok) {
    // setiap grup menolak peluncuran; setiap entri mencantumkan semua kendala gagal grup itu
    for (const group of result.groupFailures) {
      for (const c of group.unsatisfied) {
        console.log(
          `group ${group.groupId}: ${LaunchpadCurveRuleField[c.field]} is ${c.actual ?? "not computable"},`,
          `rule wants op ${c.op} ${c.value.toString()}`,
        );
      }
    }
  }
}
```

Tiga hal yang direproduksi pembantu daripada perkiraan:

* **Akun aturan yang hilang, dan aturan tanpa grup, keduanya lulus.** Begitu juga grup tanpa kendala. Lewati `rule: undefined` untuk akun yang tidak ada; jangan perlakukan sebagai penolakan.
* **Nilai yang tidak dapat dihitung gagal tertutup.** Suplai nol tidak memiliki tingkat, dan jumlah terkunci lebih besar dari apa yang tersisa penjualan kurva tidak memiliki jumlah migrasi. `actual` kembali `undefined` dan kendala dihitung sebagai tidak puas, persis seperti on-chain.
* **Semua kendala gagal dilaporkan, bukan hanya yang pertama.** Program short-circuit karena hanya membutuhkan putusan; pembantu mengumpulkan semuanya sehingga formulir Anda dapat mencantumkan setiap masalah sekaligus.

Satu-satunya hal yang tidak dapat diketahui adalah waktu blok transaksi Anda akan benar-benar mendarat. Jika aturan menggunakan `UnixTimestamp` dekat batas, perlakukan lulus sebagai sementara.

### Sebelum menulis aturan: apakah grup ini valid?

`checkCurveRuleGroupWritable` mencerminkan validasi waktu tulis `UpdatePlatformCurveRule` — id kendala, aturan duplikat `(field, op)`, batas hitungan keduanya, dan pembatasan tipe kurva. Jalankan di alat admin platform Anda sebelum menandatangani.

```ts theme={null}
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,
  // id yang sudah dipegang aturan, jadi mengganti grup tidak disalahartikan sebagai menambah satu
  existingGroupIds: existingRule?.groups.map((g) => g.groupId) ?? [],
});

// setiap kesalahan membawa kode kesalahan program yang transaksi akan gagal
if (!writable.ok) console.log(writable.errors);
```

<Note>
  Melewati pemeriksaan ini berarti transaksi tidak akan ditolak karena salah bentuk. Ini tidak mengatakan apa pun tentang apakah aturan adalah apa yang Anda maksudkan — grup dapat sempurna valid dan masih menolak setiap peluncuran yang dapat dihasilkan UI Anda. Itulah yang dimaksudkan pemeriksaan sisi peluncuran di atas: setelah menulis grup, jalankan setiap bentuk yang dapat dihasilkan produk Anda melalui `checkLaunchAgainstCurveRule` dan konfirmasi masing-masing masih menemukan grup.
</Note>

### Uji di devnet terlebih dahulu

Mengaktifkan `restrict_curve_param` di mainnet mengubah apa yang dapat dilakukan kreator Anda, segera, untuk setiap peluncuran. Latih seluruh urutan di devnet sebelum Anda menyentuh mainnet:

1. Buat konfigurasi platform dan aturan di devnet, dan tulis grup yang sama yang Anda maksudkan untuk dikirim.
2. Jalankan setiap bentuk peluncuran yang dapat dihasilkan UI Anda melalui `checkLaunchAgainstCurveRule`, dan konfirmasi putusan adalah yang Anda harapkan — baik bentuk yang harus lulus maupun bentuk yang harus ditolak.
3. Aktifkan `restrict_curve_param`, kemudian benar-benar luncurkan token yang harus lulus dan satu yang harus ditolak. Yang kedua harus gagal dengan `CurveParamNotMatchPlatformRule` (`6025`), bukan dengan `NotEnoughRemainingAccounts` (`6018`) — yang terakhir berarti pembangun Anda tidak menambahkan PDA aturan dan pemeriksaan tidak benar-benar dijalankan.
4. Hanya kemudian ulangi di mainnet, dalam urutan yang sama.

Arahkan SDK ke devnet dengan `cluster: "devnet"` ketika Anda memuatnya, dan ambil ID program devnet dari [`reference/program-addresses`](/id/reference/program-addresses).

Langkah 3 adalah yang layak didesak. Pembantu off-chain dan program on-chain adalah dua implementasi aturan yang sama, dan peluncuran devnet adalah apa yang membuktikan mereka setuju untuk aturan Anda — termasuk bahwa pembangun peluncuran Anda melewati akun sama sekali.

## Mengoperasikan aturan

### Manajer yang didelegasikan

Mengedit aturan adalah pekerjaan rutin; kunci admin platform biasanya multisig. `PlatformConfig.curve_rule_manager` ada untuk tepat itu: atur sekali melalui `UpdatePlatformConfig::CurveRuleManager`, dan dompet panas itu kemudian dapat membuat, memperbarui, menghapus, dan menutup akun aturan sendiri. Admin platform mempertahankan kekuatan yang sama secara paralel, jadi kunci manajer yang hilang dapat dipulihkan — rotasi dengan panggilan admin lain.

Cakupan kunci manajer yang dikompromikan: dapat melonggarkan atau menghapus aturan parameter Anda, dan dapat mengklaim sewa akun aturan. Tidak dapat menyentuh dompet biaya, vesting, konfigurasi CPMM, tidak dapat membalik `restrict_curve_param`, dan tidak dapat melanggar batas `GlobalConfig`. Perlakukan sebagai kunci konfigurasi, bukan kunci perbendaharaan.

### Sewa mengikuti konten

Akun aturan dibuat tanpa grup dan diubah ukurannya pada setiap perubahan, jadi Anda membayar aturan yang benar-benar Anda tulis. Menghapus grup mengembalikan perbedaan ke penandatangan.

| Konten aturan                     | Ukuran akun | Sewa         |
| --------------------------------- | ----------- | ------------ |
| Kosong (baru dibuat)              | 150 bytes   | \~0.0019 SOL |
| 1 grup, 2 kendala                 | 200 bytes   | \~0.0023 SOL |
| 3 grup, 4 kendala masing-masing   | 408 bytes   | \~0.0037 SOL |
| 10 grup, 25 kendala masing-masing | 4 790 bytes | \~0.034 SOL  |

### Urutan peluncuran

1. Latih seluruh urutan di devnet — lihat [Uji di devnet terlebih dahulu](#uji-di-devnet-terlebih-dahulu).
2. Buat akun aturan dan tulis grupnya. Tidak ada yang berubah — dengan `restrict_curve_param` masih `0` program tidak membacanya.
3. Periksa aturan off-chain dengan [`checkLaunchAgainstCurveRule`](#sebelum-peluncuran-apakah-parameter-ini-akan-lulus): untuk setiap bentuk peluncuran yang dapat dihasilkan UI Anda, konfirmasi beberapa grup menerimanya.
4. Atur `restrict_curve_param` ke `1`. Dari saat itu peluncuran kreator Anda diperiksa.
5. Untuk memutar kembali, atur ke `0` lagi. Akun aturan dibiarkan utuh.

<Warning>
  Pembangun peluncuran Anda harus menambahkan PDA aturan ke `remaining_accounts` saat `restrict_curve_param` adalah `1`. Program memerlukan akun hadir bahkan ketika belum ada, jadi kreator tidak dapat melewati pemeriksaan dengan menghilangkannya — akun yang hilang adalah `NotEnoughRemainingAccounts`, bukan lulus. Derivasi adalah `[b"platform_curve_rule", platform_config, global_config]`.
</Warning>

## Biaya pada waktu peluncuran

Pemeriksaan berjalan pada setiap peluncuran saat diaktifkan, jadi biaya komputasinya adalah pajak per-peluncuran. Diukur end-to-end — derivasi PDA, pemindaian `remaining_accounts`, deserialisasi, dan evaluasi:

| Konten aturan                     | Field murah | Field turunan |
| --------------------------------- | ----------- | ------------- |
| Diaktifkan, tidak ada akun aturan | 1 936       | —             |
| 1 grup, 2 kendala                 | 2 576       | 2 926         |
| 3 grup, 4 kendala masing-masing   | 3 624       | 5 724         |
| 10 grup, 25 kendala masing-masing | 24 344      | 68 094        |

"Murah" adalah pembacaan field langsung seperti `Supply`; "turunan" adalah yang dihitung seperti `MigrateRateA`, yang biaya sekitar 223 CU per kendala terhadap sekitar 48. Bahkan aturan yang sepenuhnya dimuat dari kendala turunan tetap di dalam sepertiga dari anggaran default 200 000 CU per-instruksi, dan aturan tiga-grup yang realistis di bawah 6 000. Grup dievaluasi sampai satu cocok, jadi memesan tingkat umum Anda terlebih dahulu adalah penghematan gratis.

## Ke mana selanjutnya

* [`products/launchlab/platform-config`](/id/products/launchlab/platform-config) — field `PlatformConfig` yang gerbang dan mendelegasikan aturan.
* [`products/launchlab/global-config`](/id/products/launchlab/global-config) — lantai protokol yang dipersempit aturan.
* [`products/launchlab/instructions`](/id/products/launchlab/instructions) — empat instruksi aturan dan akun mereka.
* [`products/launchlab/accounts`](/id/products/launchlab/accounts) — `PlatformCurveRule` dalam inventaris akun.
* [`sdk-api/typescript-sdk`](/id/sdk-api/typescript-sdk) — permukaan SDK tempat dua pembantu pemeriksaan hidup.
* [`reference/changelog/2026-08-31-launchlab-platform-curve-rules`](/id/reference/changelog/2026-08-31-launchlab-platform-curve-rules) — apa yang menggantikan daftar putih parameter kurva, dan apa yang harus diubah decoder.

Sumber:

* `raydium-launch/programs/launchpad/src/states/platform_curve_rule.rs` — `PlatformCurveRule`, `CurveRuleGroup`, `ParamConstraint`, ruang id field dan op, dan `CurveRuleContext::value_of`.
* `raydium-launch/programs/launchpad/src/utils/platform_curve_rule.rs` — pemeriksaan waktu peluncuran.
* `raydium-launch/programs/launchpad/src/instructions/platform/` — `create`, `update`, `remove`, dan `close_platform_curve_rule`.