> ## 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.
# Reglas de curva de LaunchLab
> Cómo una plataforma restringe los parámetros de lanzamiento que sus creadores pueden elegir: grupos de verificación, el modelo de restricción (campo, operador, valor), y nueve patrones — niveles exactos, bandas de valor, límites de valuación de graduación, pisos de migración, restricción por tipo de token, y promociones limitadas en tiempo.
**Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.**
[Ver versión en inglés →](/products/launchlab/curve-rules)
Una **regla de curva** es la respuesta de una plataforma a "¿qué lanzamientos estoy dispuesto a alojar?". [`GlobalConfig`](/es/products/launchlab/global-config) establece el piso del protocolo — al menos 10M de suministro, al menos 20% del suministro vendido en la curva, y así sucesivamente — y esos pisos son deliberadamente amplios para que cada tipo de plataforma quepa bajo ellos. Una regla de curva es donde tu plataforma los estrecha a la forma que tu producto realmente soporta.
Las reglas viven en su propia cuenta `PlatformCurveRule`, una por cada par (plataforma, [`GlobalConfig`](/es/products/launchlab/global-config)). Solo pueden estrechar lo que la configuración ya permite; una regla nunca puede ampliar un límite del protocolo.
## El modelo mental
Tres niveles, de afuera hacia adentro:
```
GlobalConfig piso del protocolo "suministro >= 10M, tasa de venta >= 20%, ..."
└─ PlatformCurveRule tu regla "y en mi plataforma: una de estas formas"
└─ grupo de verificación una forma "suministro = 1B Y recaudación de fondos en [80, 90] SOL"
└─ restricción una verificación "(Supply, Eq, 1_000_000_000)"
```
Los dos niveles de anidamiento son lo que hace esto expresivo:
* **Las restricciones dentro de un grupo están ANDadas.** Todas deben cumplirse.
* **Los grupos dentro de una regla están OReados.** Un lanzamiento se permite tan pronto como satisface cualquier grupo único.
Entonces un grupo es una *forma* permitida, y la regla es el menú de formas que ofreces. Una regla puede contener hasta 10 grupos, y un grupo hasta 25 restricciones.
Hay dos casos límite que vale la pena memorizar:
| Estado | Significado |
| ------------------------------------------------ | ----------------------------------------------------------------------------------- |
| Sin cuenta de regla, o una regla con cero grupos | La plataforma no restringe los parámetros de lanzamiento para esa configuración. |
| Un grupo con cero restricciones | Ese grupo coincide con cada lanzamiento, por lo que la regla completa permite todo. |
Una regla entra en vigor solo mientras `PlatformConfig.restrict_curve_param` es `1`. En `0` el programa no lee las reglas en absoluto, que es también el interruptor que usas para desplegar una regla y para revertirla.
## Restricciones
Una restricción es una triple `(campo, operador, valor)`. Nada más — sin expresiones, sin anidamiento.
```rust theme={null}
pub struct ParamConstraint {
pub field: u8, // qué parámetro de lanzamiento, ver la tabla abajo
pub op: u8, // 0 Eq, 1 Gte (mín), 2 Lte (máx), 3 Neq
pub value: u128,
}
```
Un **rango son dos restricciones** en el mismo campo dentro de un grupo: un `Gte` para el piso y un `Lte` para el techo. El mismo par `(campo, operador)` no puede aparecer dos veces en un grupo, lo que te impide escribir dos mínimos contradictorios.
### Campos
Los ids de campo son permanentes. Los nuevos campos solo se añaden, por lo que un id nunca cambia de significado una vez que una cuenta de regla lo contiene.
| id | Campo | Unidad | Notas |
| -- | ------------------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| 0 | `CurveType` | enum | 0 producto constante, 1 precio fijo, 2 precio lineal |
| 1 | `MigrateType` | enum | Los nuevos lanzamientos deben ser `1` (CPMM) de todas formas |
| 2 | `MigrateCpmmFeeOn` | enum | 0 solo cotización, 1 ambos tokens |
| 3 | `Supply` | unidades base | El suministro de token completo |
| 4 | `TotalSellA` | unidades base | Vendido en la curva. Solo configuraciones de producto constante — ver [Restricciones de tipo de curva](#restricciones-de-tipo-de-curva) |
| 5 | `TotalFundRaisingB` | unidades de cotización | El objetivo de graduación |
| 6 | `TotalLockedAmount` | unidades base | Presupuesto de vesting |
| 7 | `CliffPeriod` | segundos | Espera antes de que comience el desbloqueo |
| 8 | `UnlockPeriod` | segundos | Duración del desbloqueo |
| 9 | `BaseTokenProgram` | enum | 0 SPL Token, 1 Token-2022 |
| 10 | `TransferFeeEnabled` | bool | 1 cuando el mint base lleva `TransferFeeConfig` |
| 11 | `TransferFeeBasisPoints` | 1/10 000 | 0 sin la extensión |
| 12 | `TransferFeeMaximumFee` | unidades base | 0 sin la extensión |
| 13 | `SellRateA` | 1/1 000 000 | Derivado: `TotalSellA / Supply`. Solo producto constante |
| 14 | `LockRate` | 1/1 000 000 | Derivado: `TotalLockedAmount / Supply` |
| 15 | `MigrateAmountA` | unidades base | Derivado: `Supply − TotalSellA − TotalLockedAmount`. Solo producto constante |
| 16 | `MigrateRateA` | 1/1 000 000 | Derivado: `MigrateAmountA / Supply`. Solo producto constante |
| 17 | `FundRaisingRateB` | 1/1 000 000 | Derivado: `TotalFundRaisingB / Supply` |
| 18 | `UnixTimestamp` | segundos | Tiempo de bloque del lanzamiento |
Los campos derivados son los que hacen las reglas portátiles. Fijar `Supply` y `TotalFundRaisingB` a números exactos fija una forma de lanzamiento; restringir `FundRaisingRateB` fija la *relación* entre ellos y permite que un creador elija cualquier suministro que la mantenga.
Los campos de tasa solo son comparables dentro de una `GlobalConfig`, porque sus denominadores dependen del mint de cotización de esa configuración y sus decimales. Esto no es una limitación en la práctica: una regla está limitada a una configuración por construcción.
## Los nueve patrones
Cada patrón abajo es una regla. Las restricciones se escriben como `(campo, operador, valor)`.
### 1. Un nivel estándar
La regla más simple, y el comportamiento exacto que ofrecía la lista blanca de parámetros de curva retirada: una forma, fijada.
| Grupo | Restricciones |
| ----- | --------------------------------------------------------------------------------------------------- |
| 0 | `(Supply, Eq, 1_000_000_000e6)`, `(TotalSellA, Eq, 800_000_000e6)`, `(TotalFundRaisingB, Eq, 85e9)` |
Cualquier lanzamiento que se desvíe en cualquiera de los tres es rechazado con `CurveParamNotMatchPlatformRule`.
### 2. Una banda en lugar de un número
La razón por la que existen las bandas: un creador elige un objetivo de recaudación de fondos con el que te sientes cómodo, sin que tengas que enumerar cada valor.
| Grupo | Restricciones |
| ----- | ---------------------------------------------------------------------------------------------------- |
| 0 | `(Supply, Eq, 1_000_000_000e6)`, `(TotalFundRaisingB, Gte, 50e9)`, `(TotalFundRaisingB, Lte, 200e9)` |
Un grupo, cuatro restricciones, y el creador tiene un corredor de 50–200 SOL. Bajo la lista blanca anterior esto necesitaba una entrada por cada valor permitido, y el límite de diez entradas lo hacía imposible.
### 3. Niveles lado a lado
Los grupos están OReados, así que cada nivel es un grupo.
| Grupo | Restricciones | Nivel |
| ----- | ------------------------------------------------------------------- | -------- |
| 0 | `(Supply, Eq, 1_000_000_000e6)`, `(TotalFundRaisingB, Eq, 85e9)` | Estándar |
| 1 | `(Supply, Eq, 100_000_000e6)`, `(TotalFundRaisingB, Eq, 30e9)` | Pequeño |
| 2 | `(Supply, Eq, 10_000_000_000e6)`, `(TotalFundRaisingB, Gte, 500e9)` | Ballena |
El orden importa para el cómputo, no para la semántica: la evaluación se detiene en el primer grupo que coincide, así que pon tu nivel más usado primero.
### 4. Una banda de valuación de graduación
`FundRaisingRateB` es `TotalFundRaisingB / Supply` en millonésimas. Restringirlo limita cuán ricamente un token puede graduarse independientemente del suministro que el creador eligió.
| Grupo | Restricciones |
| ----- | --------------------------------------------------------------------- |
| 0 | `(FundRaisingRateB, Gte, 60_000)`, `(FundRaisingRateB, Lte, 120_000)` |
Con un suministro de 1e12 y un mint de cotización de 9 decimales, `85e9 / 1e12 × 1e6 = 85_000` se sitúa dentro de esa banda. Un creador que duplica el suministro debe aproximadamente duplicar el objetivo para mantenerse en ella — que es el punto. Dos restricciones reemplazan lo que de otro modo sería una tabla de pares `(suministro, objetivo)`.
### 5. Un piso de migración
`MigrateRateA` es la parte del suministro que realmente llega al pool CPMM en la graduación: `Supply − TotalSellA − TotalLockedAmount`, sobre el suministro. Es la profundidad del pool graduado, y es el único control del protocolo sin equivalente del lado de la plataforma antes de que existieran las reglas.
| Grupo | Restricciones |
| ----- | ------------------------------ |
| 0 | `(MigrateRateA, Gte, 150_000)` |
Al menos el 15% del suministro llega al pool. Un creador no puede vender el 95% en la curva y dejar un libro poco profundo atrás.
Si los parámetros no suman — una cantidad bloqueada más grande que lo que queda después de la venta de la curva — el valor derivado no puede ser computado y la restricción falla cerrada, por lo que el lanzamiento es rechazado en lugar de ser silenciosamente permitido.
### 6. Vesting que realmente aplicas
`GlobalConfig.max_lock_rate` limita el vesting desde arriba. Una regla puede poner un piso bajo él, y requerir un acantilado real.
| Grupo | Restricciones |
| ----- | -------------------------------------------------------------------------------------- |
| 0 | `(LockRate, Gte, 50_000)`, `(LockRate, Lte, 200_000)`, `(CliffPeriod, Gte, 2_592_000)` |
Entre el 5% y el 20% del suministro bloqueado, con al menos un acantilado de 30 días. Útil para una plataforma cuya propuesta es "sin lanzamientos de desbloqueo instantáneo".
### 7. Restricción por tipo de token
`BaseTokenProgram` y `TransferFeeEnabled` son independientes, lo que importa: un mint Token-2022 sin `TransferFeeConfig` reporta `TransferFeeEnabled = 0` igual que un mint SPL Token.
| Intención | Grupo | Restricciones |
| ----------------------------------------------- | ----- | ---------------------------------------------------------- |
| Solo SPL Token | 0 | `(BaseTokenProgram, Eq, 0)` |
| Solo Token-2022 | 0 | `(BaseTokenProgram, Eq, 1)` |
| Token-2022, sin tarifa de transferencia | 0 | `(BaseTokenProgram, Eq, 1)`, `(TransferFeeEnabled, Eq, 0)` |
| Sin tarifa de transferencia, cualquier programa | 0 | `(TransferFeeEnabled, Eq, 0)` |
### 8. Un límite de tarifa de transferencia condicional
No hay operador "si", y ninguno es necesario — dos grupos expresan la condición.
| Grupo | Restricciones | Se lee como |
| ----- | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| 0 | `(TransferFeeEnabled, Eq, 0)` | Sin tarifa de transferencia: está bien |
| 1 | `(TransferFeeEnabled, Eq, 1)`, `(TransferFeeBasisPoints, Lte, 100)`, `(TransferFeeMaximumFee, Gte, 1_000)` | Con una tarifa: como máximo 1%, y una tarifa máxima que realmente está establecida |
Una `TransferFeeConfig` de tasa cero no se cuela a través del grupo 0: la extensión está presente, así que `TransferFeeEnabled` es `1` y solo el grupo 1 puede aceptarla.
### 9. Una promoción limitada en tiempo, programada por adelantado
`UnixTimestamp` es el tiempo de bloque del lanzamiento, así que un grupo puede llevar su propia ventana de validez. Escribes ambos grupos hoy y el cambio sucede por sí solo.
| Grupo | Restricciones | Ventana |
| ----- | ----------------------------------------------------------------------- | ----------------------------------- |
| 0 | `(UnixTimestamp, Lte, 1_767_225_600)`, `(TotalFundRaisingB, Gte, 30e9)` | Período de promoción: mínimo 30 SOL |
| 1 | `(UnixTimestamp, Gte, 1_767_225_601)`, `(TotalFundRaisingB, Gte, 80e9)` | Después: mínimo 80 SOL |
No se necesita transacción en el límite. El costo es dos espacios de grupo en lugar de uno.
## Restricciones de tipo de curva
Cuatro campos leen `TotalSellA`: `TotalSellA`, `SellRateA`, `MigrateAmountA`, y `MigrateRateA`. En una configuración de producto constante el creador suministra ese número. En una configuración de precio fijo o precio lineal la curva lo deriva en su lugar, y el valor que el programa compara es `0`, lo que rechazaría cada lanzamiento.
En lugar de permitirte escribir una regla que silenciosamente bloquea tu propia configuración, el programa rechaza esos cuatro campos en tiempo de escritura en una configuración que no es de producto constante, con `CurveRuleFieldNotSupportedByCurve`. Solo existen configuraciones de producto constante hoy, así que en la práctica no encontrarás este error.
## Verifica antes de enviar
Ambas direcciones de la verificación en cadena están disponibles fuera de cadena, así que ni un creador ni una plataforma tiene que aprender una regla viendo transacciones revertidas.
**Banner de versión.**
* SDK: `@raydium-io/raydium-sdk-v2@0.2.42-alpha` es la versión a la que se fija cada otra demostración de código en este sitio. Los dos ayudantes abajo llegan con la versión del SDK que envía soporte de regla de curva; hasta entonces, portarlos del `platform_curve_rule.rs` del programa o llamar al programa y leer el código de error.
* Cluster: prueba primero en Solana `devnet` — ver [Prueba en devnet primero](#prueba-en-devnet-primero).
* ID del programa: ver [`reference/program-addresses`](/es/reference/program-addresses)
Ambos ayudantes son funciones puras. No tocan RPC, así que son seguros para ejecutar en cada pulsación de tecla en un formulario.
### Antes de un lanzamiento: ¿pasarán estos parámetros?
`checkLaunchAgainstCurveRule` refleja la verificación de tiempo de lanzamiento del programa exactamente, incluyendo su comportamiento de falla cerrada. Ejecútalo en tu formulario de lanzamiento y puedes desactivar el botón de envío con una razón en lugar de permitir que el creador pague por una transacción revertida.
```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);
// en 0 el programa no lee las reglas en absoluto, así que no hay nada que verificar
if (platformConfig.restrictCurveParam !== 0) {
const ruleId = getPdaPlatformCurveRule(programId, platformConfigId, configId).publicKey;
const ruleAccount = await connection.getAccountInfo(ruleId);
const result = checkLaunchAgainstCurveRule({
// undefined cuando la cuenta no existe — la plataforma no escribió una regla para esta configuración
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,
// omite transferFee completamente cuando el mint base no lleva extensión de tarifa de transferencia
unixTimestamp: new BN(Math.floor(Date.now() / 1000)),
},
});
if (!result.ok) {
// cada grupo rechazó el lanzamiento; cada entrada lista todas las restricciones fallidas de ese grupo
for (const group of result.groupFailures) {
for (const c of group.unsatisfied) {
console.log(
`grupo ${group.groupId}: ${LaunchpadCurveRuleField[c.field]} es ${c.actual ?? "no computable"},`,
`la regla quiere op ${c.op} ${c.value.toString()}`,
);
}
}
}
}
```
Tres cosas que el ayudante reproduce en lugar de aproximar:
* **Una cuenta de regla faltante, y una regla sin grupo, ambas pasan.** También lo hace un grupo sin restricciones. Pasa `rule: undefined` para una cuenta inexistente; no la trates como un rechazo.
* **Los valores no computables fallan cerrados.** Un suministro cero no tiene tasas, y una cantidad bloqueada más grande que lo que la venta de la curva deja no tiene cantidad de migración. `actual` vuelve `undefined` y la restricción cuenta como insatisfecha, exactamente como en cadena.
* **Se reportan todas las restricciones fallidas, no solo la primera.** El programa hace cortocircuito porque solo necesita un veredicto; el ayudante recopila todo para que tu formulario pueda listar cada problema a la vez.
Lo único que no puede saber es el tiempo de bloque en el que tu transacción realmente aterrizará. Si una regla usa `UnixTimestamp` cerca de un límite, trata un pase como provisional.
### Antes de escribir una regla: ¿es este grupo válido?
`checkCurveRuleGroupWritable` refleja la validación de tiempo de escritura de `UpdatePlatformCurveRule` — ids de restricción, la regla de `(campo, operador)` duplicado, ambos límites de conteo, y la restricción de tipo de curva. Ejecútalo en tu herramienta de administrador de plataforma antes de firmar.
```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,
// los ids que la regla ya contiene, así que reemplazar un grupo no se confunde con agregar uno
existingGroupIds: existingRule?.groups.map((g) => g.groupId) ?? [],
});
// cada error lleva el código de error del programa con el que la transacción habría fallado
if (!writable.ok) console.log(writable.errors);
```
Pasar esta verificación significa que la transacción no será rechazada por estar mal formada. No dice nada sobre si la regla es lo que pretendías — un grupo puede ser perfectamente válido y aún rechazar cada lanzamiento que tu interfaz puede producir. Eso es para lo que sirve la verificación del lado del lanzamiento anterior: después de escribir un grupo, ejecuta cada forma que tu producto ofrece a través de `checkLaunchAgainstCurveRule` y confirma que cada una aún encuentra un grupo.
### Prueba en devnet primero
Habilitar `restrict_curve_param` en mainnet cambia lo que tus creadores pueden hacer, inmediatamente, para cada lanzamiento. Ensaya toda la secuencia en devnet antes de tocar mainnet:
1. Crea una configuración de plataforma y una regla en devnet, y escribe los mismos grupos que tienes la intención de enviar.
2. Ejecuta cada forma de lanzamiento que tu interfaz puede producir a través de `checkLaunchAgainstCurveRule`, y confirma que los veredictos son los que esperas — tanto las formas que deberían pasar como las formas que deberían ser rechazadas.
3. Habilita `restrict_curve_param`, luego realmente lanza un token que debería pasar y uno que debería ser rechazado. El segundo debería fallar con `CurveParamNotMatchPlatformRule` (`6025`), no con `NotEnoughRemainingAccounts` (`6018`) — este último significa que tu constructor no está añadiendo el PDA de regla y la verificación no está siendo realmente ejercida.
4. Solo entonces repite en mainnet, en el mismo orden.
Apunta el SDK a devnet con `cluster: "devnet"` cuando lo cargues, y toma el ID del programa devnet de [`reference/program-addresses`](/es/reference/program-addresses).
El paso 3 es el que vale la pena insistir. El ayudante fuera de cadena y el programa en cadena son dos implementaciones de las mismas reglas, y un lanzamiento en devnet es lo que prueba que están de acuerdo para tu regla — incluyendo que tu constructor de lanzamiento pasa la cuenta en absoluto.
## Operando una regla
### El gerente delegado
Editar reglas es trabajo rutinario; una clave de administrador de plataforma es generalmente un multisig. `PlatformConfig.curve_rule_manager` existe exactamente para eso: establécelo una vez a través de `UpdatePlatformConfig::CurveRuleManager`, y ese monedero caliente puede entonces crear, actualizar, eliminar, y cerrar cuentas de regla por su cuenta. El administrador de la plataforma retiene el mismo poder en paralelo, así que una clave de gerente perdida es recuperable — rótala con otra llamada de administrador.
Alcance de una clave de gerente comprometida: puede aflojar o eliminar tus reglas de parámetros, y puede reclamar la renta de una cuenta de regla. No puede tocar billeteras de tarifas, vesting, la configuración de CPMM, no puede voltear `restrict_curve_param`, y no puede romper un límite de `GlobalConfig`. Trátala como una clave de configuración, no una clave de tesorería.
### La renta sigue el contenido
Una cuenta de regla se crea sin grupo y se redimensiona en cada cambio, así que pagas por las reglas que realmente escribiste. Eliminar un grupo reembolsa la diferencia al firmante.
| Contenido de regla | Tamaño de cuenta | Renta |
| ------------------------------------ | ---------------- | ------------ |
| Vacío (recién creado) | 150 bytes | \~0.0019 SOL |
| 1 grupo, 2 restricciones | 200 bytes | \~0.0023 SOL |
| 3 grupos, 4 restricciones cada uno | 408 bytes | \~0.0037 SOL |
| 10 grupos, 25 restricciones cada uno | 4 790 bytes | \~0.034 SOL |
### Orden de despliegue
1. Ensaya toda la secuencia en devnet — ver [Prueba en devnet primero](#prueba-en-devnet-primero).
2. Crea la cuenta de regla y escribe sus grupos. Nada cambia aún — con `restrict_curve_param` aún en `0` el programa no las lee.
3. Verifica la regla fuera de cadena con [`checkLaunchAgainstCurveRule`](#antes-de-un-lanzamiento-pasarán-estos-parámetros): para cada forma de lanzamiento que tu interfaz puede producir, confirma que algún grupo la acepta.
4. Establece `restrict_curve_param` a `1`. Desde ese momento los lanzamientos de tus creadores son verificados.
5. Para revertir, establécelo a `0` nuevamente. La cuenta de regla se deja intacta.
Tu constructor de lanzamiento debe añadir el PDA de regla a `remaining_accounts` mientras `restrict_curve_param` es `1`. El programa requiere que la cuenta esté presente incluso cuando aún no existe, para que un creador no pueda saltarse la verificación omitiendo — una cuenta faltante es `NotEnoughRemainingAccounts`, no un pase. La derivación es `[b"platform_curve_rule", platform_config, global_config]`.
## Costo en tiempo de lanzamiento
La verificación se ejecuta en cada lanzamiento mientras está habilitada, así que su costo de cómputo es un impuesto por lanzamiento. Medido de extremo a extremo — derivación de PDA, el escaneo de `remaining_accounts`, deserialización, y evaluación:
| Contenido de regla | Campos baratos | Campos derivados |
| ------------------------------------ | -------------- | ---------------- |
| Habilitado, sin cuenta de regla | 1 936 | — |
| 1 grupo, 2 restricciones | 2 576 | 2 926 |
| 3 grupos, 4 restricciones cada uno | 3 624 | 5 724 |
| 10 grupos, 25 restricciones cada uno | 24 344 | 68 094 |
"Barato" es una lectura de campo directo como `Supply`; "derivado" es uno computado como `MigrateRateA`, que cuesta aproximadamente 223 CU por restricción contra aproximadamente 48. Incluso una regla completamente cargada de restricciones derivadas se mantiene dentro de un tercio del presupuesto predeterminado de 200 000 CU por instrucción, y una regla realista de tres grupos está bajo 6 000. Los grupos se evalúan hasta que uno coincide, así que ordenar tu nivel común primero es ahorro libre.
## A dónde ir después
* [`products/launchlab/platform-config`](/es/products/launchlab/platform-config) — los campos de `PlatformConfig` que cierran y delegan reglas.
* [`products/launchlab/global-config`](/es/products/launchlab/global-config) — los pisos del protocolo que una regla estrecha.
* [`products/launchlab/instructions`](/es/products/launchlab/instructions) — las cuatro instrucciones de regla y sus cuentas.
* [`products/launchlab/accounts`](/es/products/launchlab/accounts) — `PlatformCurveRule` en el inventario de cuentas.
* [`sdk-api/typescript-sdk`](/es/sdk-api/typescript-sdk) — la superficie del SDK donde viven los dos ayudantes de verificación.
* [`reference/changelog/2026-08-31-launchlab-platform-curve-rules`](/es/reference/changelog/2026-08-31-launchlab-platform-curve-rules) — lo que reemplazó la lista blanca de parámetros de curva, y qué decodificadores deben cambiar.
Fuentes:
* `raydium-launch/programs/launchpad/src/states/platform_curve_rule.rs` — `PlatformCurveRule`, `CurveRuleGroup`, `ParamConstraint`, los espacios de id de campo y operador, y `CurveRuleContext::value_of`.
* `raydium-launch/programs/launchpad/src/utils/platform_curve_rule.rs` — la verificación de tiempo de lanzamiento.
* `raydium-launch/programs/launchpad/src/instructions/platform/` — `create`, `update`, `remove`, y `close_platform_curve_rule`.