Saltar al contenido principal

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.

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 →

​
Resumen de instrucciones

EtiquetaDiscriminadorExactitudVariante
0SwapBaseInWithUserAccountEntradaLegacy
1SwapBaseOutWithUserAccountSalidaLegacy
5CreateSyncNative—Utilidad
6CloseTokenAccount—Utilidad
8SwapBaseInEntradaActual
9SwapBaseOutSalidaActual
Leyenda:
  • Exactitud: cuál cantidad es fija según el llamador (Entrada = amount_in exacto; Salida = amount_out exacto).
  • Variante: Las instrucciones Legacy requieren una deque limit_prices no vacía incluso si no hay saltos CLMM en la ruta. Las instrucciones actuales (8 / 9) tratan una limit_prices vacía como “sin verificaciones”, que es el camino recomendado para código nuevo.
Todas las variantes de swap enrutan tokens intermedios a través de ATAs controladas por el usuario — el usuario es dueño de la ATA de entrada, cada ATA intermedia y la ATA de salida. Para nuevas integraciones, utiliza etiqueta 8 (SwapBaseIn) o etiqueta 9 (SwapBaseOut) a menos que tengas una razón específica para llamar a una variante Legacy.

​
Instrucciones de swap actuales (recomendadas)

Estos son los puntos de entrada que debe usar el código nuevo. La estructura de argumentos es la misma que en las variantes Legacy, pero limit_prices puede estar vacía.

​
SwapBaseIn (etiqueta 8)

Swap multi-salto de entrada exacta. El llamador fija amount_in; el enrutador ejecuta salto a salto y afirma que la cantidad final se sitúa en o por encima de minimum_amount_out. Argumentos 
amount_in:            u64
minimum_amount_out:   u64
limit_prices:         VecDeque<u128>  // opcional; deque vacía significa sin verificación de precio CLMM por salto
Cuentas 
[
  <user_input_ata> W S,         // firmante; balance >= amount_in
  <user_intermediate_ata_1> W,  // una por cada salto intermedio
  ... <user_intermediate_ata_N> W,
  <user_output_ata> W,
  <token_program>,

  <pool_program_hop_1>,         // identifica a qué familia AMM pertenece el salto 1
  <pool_state_hop_1> W,
  ... <otras cuentas requeridas por el programa del salto 1>,

  <pool_program_hop_2>,
  <pool_state_hop_2> W,
  ... <cuentas del salto 2>,

  ... [repetir por cada salto]
]
La lista exacta de cuentas por salto depende del programa AMM subyacente (AMM v4 / CPMM / CLMM / Stable). El enrutador realiza CPI en cada uno a su vez y valida que el ID del programa coincida con uno de los cuatro programas soportados. Precondiciones
  • El llamador firma con user_input_ata.
  • user_input_ata.amount >= amount_in.
  • Cada ATA de usuario intermedia existe y es propiedad del llamador.
  • Si algún salto es CLMM y deseas aplicar límites de precio, proporciona una entrada limit_prices por cada salto CLMM.
Postcondiciones
  • El balance de user_input_ata disminuye en amount_in.
  • El balance de user_output_ata aumenta en ≥ minimum_amount_out.
  • Cada ATA intermedia se deja con cambio neto cero (la ruta consume lo que produjo un salto anterior).
Errores comunes
  • ExceededSlippage — salida final < minimum_amount_out.
  • InvalidInput — ruta vacía, cuentas malformadas o pool_program no soportado.
  • SqrtPriceX64 — el precio de un salto CLMM se movió fuera del límite limit_prices suministrado (solo cuando limit_prices es no vacía).

​
SwapBaseOut (etiqueta 9)

Swap multi-salto de salida exacta. El llamador fija amount_out; el enrutador afirma que la entrada real no excede maximum_amount_in. Argumentos 
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // opcional; deque vacía significa sin verificación de precio CLMM por salto
Cuentas — la misma estructura que la etiqueta 8. Precondiciones
  • El llamador firma con user_input_ata; balance >= maximum_amount_in (peor caso).
  • Cada ATA intermedia y de salida existen.
Postcondiciones
  • user_input_ata disminuye en la cantidad real necesaria (≤ maximum_amount_in).
  • user_output_ata aumenta exactamente en amount_out.
Errores comunes
  • ExceededSlippage — entrada requerida excede maximum_amount_in.
  • InvalidInput, SqrtPriceX64 — igual que para la etiqueta 8.

​
Instrucciones de swap Legacy

Estas variantes antiguas aún se pueden llamar en el programa activo y se documentan aquí por completitud. Prefiere etiqueta 8 / etiqueta 9 para código nuevo; ambas variantes Legacy a continuación requieren una deque limit_prices no vacía incluso cuando no hay saltos CLMM involucrados, lo que las hace incómodas de usar.

​
SwapBaseInWithUserAccount (etiqueta 0)

Swap multi-salto de entrada exacta, idéntico en forma a la etiqueta 8 pero con el requisito más estricto de limit_prices. Argumentos 
amount_in:           u64
minimum_amount_out:  u64
limit_prices:        VecDeque<u128>  // requerida, no vacía
Cuentas — la misma forma que SwapBaseIn (etiqueta 8). Todos los espacios intermedios deben ser ATAs propiedad del llamador. Precondiciones
  • El llamador firma con user_input_ata.
  • user_input_ata.amount >= amount_in.
  • Todas las ATAs de usuario intermedia existen y son propiedad del llamador.
  • limit_prices es no vacía (una entrada por cada salto CLMM; rellena con valores placeholder si no hay saltos CLMM involucrados).
Postcondiciones
  • El balance de user_input_ata disminuye en amount_in.
  • El balance de user_output_ata aumenta en ≥ minimum_amount_out.
Errores comunes
  • ExceededSlippage.
  • InvalidInput — limit_prices vacía es rechazada en esta variante Legacy.
  • SqrtPriceX64.

​
SwapBaseOutWithUserAccount (etiqueta 1)

Swap de salida exacta, la contraparte Legacy de SwapBaseOut (etiqueta 9). Argumentos 
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // requerida, no vacía
Cuentas — la misma forma que etiqueta 0 / etiqueta 9. Precondiciones
  • El llamador firma con user_input_ata.
  • user_input_ata.amount >= maximum_amount_in.
  • Todas las ATAs de usuario intermedia existen y son propiedad del llamador.
  • limit_prices es no vacía.
Postcondiciones
  • user_input_ata disminuye en la cantidad real necesaria (≤ maximum_amount_in).
  • user_output_ata aumenta exactamente en amount_out.
Errores comunes
  • ExceededSlippage.
  • InvalidInput.
  • SqrtPriceX64.

​
Instrucciones de utilidad

​
CreateSyncNative (etiqueta 5)

Crear (si falta) y sincronizar una ATA de wSOL en un solo paso. Conveniente cuando envuelves SOL en línea junto a un swap. Argumentos 
amount: u64    // SOL a envolver (lamports)
Cuentas 
[
  <user_wsol_ata> W,            // ATA para wSOL; creada si falta
  <user_native_account> W S,    // firmante; SOL se debita de aquí
  <wsol_mint>,
  <system_program>,
  <token_program>,
  <associated_token_program>,
]
Efecto
  • Crea user_wsol_ata si aún no existe.
  • Transfiere amount lamports desde el balance de SOL nativo del firmante a la ATA.
  • Llama a SyncNative en la ATA para que su balance de tokens refleje los nuevos lamports.
Errores comunes
  • InvalidOwner — el propietario de user_wsol_ata no es el firmante.

​
CloseTokenAccount (etiqueta 6)

Cerrar una cuenta de token y devolver su renta a la billetera de destino. Se empareja con CreateSyncNative: después de un swap de ramificación wSOL, llama a CloseTokenAccount para recuperar la renta que respaldaba la ATA de wSOL. Argumentos — ninguno. Cuentas 
[
  <token_account_to_close> W,
  <destination_for_rent> W,
  <owner> S,
  <token_program>,
]
Efecto
  • Cierra token_account_to_close.
  • Transfiere el balance de lamports exento de renta (~0.00203928 SOL en mainnet para una cuenta vanilla SPL Token) a destination_for_rent.
  • La cuenta de token debe tener balance de token cero.
Errores comunes
  • InvalidOwner — el llamador no es el propietario de la ATA.
  • El balance de la cuenta de token es distinto de cero.

​
A dónde ir después