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

# Instrucciones de enrutamiento

> Referencia de las instrucciones AMM Routing habilitadas en mainnet — seis variantes que cubren swaps de entrada exacta / salida exacta y utilidades de wSOL.

<Info>
  **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/routing/instructions)
</Info>

## Resumen de instrucciones

| Etiqueta | Discriminador                | Exactitud | Variante |
| -------- | ---------------------------- | --------- | -------- |
| 0        | `SwapBaseInWithUserAccount`  | Entrada   | Legacy   |
| 1        | `SwapBaseOutWithUserAccount` | Salida    | Legacy   |
| 5        | `CreateSyncNative`           | —         | Utilidad |
| 6        | `CloseTokenAccount`          | —         | Utilidad |
| 8        | `SwapBaseIn`                 | Entrada   | Actual   |
| 9        | `SwapBaseOut`                | Salida    | Actual   |

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

* [`products/routing/code-demos`](/es/products/routing/code-demos) — construyendo cada una de estas instrucciones en TypeScript.
* [`products/routing/accounts`](/es/products/routing/accounts) — claves de envío por AMM y diseño de cuentas por salto.
* [`reference/error-codes`](/es/reference/error-codes) — lista completa de `RouteError`.