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

# Instruções de roteamento

> Referência para as instruções de roteamento AMM ativadas em mainnet — seis variantes cobrindo swaps com entrada exata / saída exata e utilitários wSOL.

<Info>
  **Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.**

  [Ver versão em inglês →](/products/routing/instructions)
</Info>

## Resumo de instruções

| Tag | Discriminador                | Exato   | Variante   |
| --- | ---------------------------- | ------- | ---------- |
| 0   | `SwapBaseInWithUserAccount`  | Entrada | Legado     |
| 1   | `SwapBaseOutWithUserAccount` | Saída   | Legado     |
| 5   | `CreateSyncNative`           | —       | Utilitário |
| 6   | `CloseTokenAccount`          | —       | Utilitário |
| 8   | `SwapBaseIn`                 | Entrada | Atual      |
| 9   | `SwapBaseOut`                | Saída   | Atual      |

**Legenda:**

* **Exato:** qual quantidade é fixada pelo chamador (Entrada = entrada exata `amount_in`; Saída = saída exata `amount_out`).
* **Variante:** instruções legadas exigem uma deque `limit_prices` não vazia mesmo se nenhum hop CLMM estiver na rota. Instruções atuais (8 / 9) tratam um `limit_prices` vazio como "sem verificações", que é o caminho recomendado para novo código.

Todas as variantes de swap roteiam tokens intermediários através de **ATAs controladas pelo usuário** — o usuário é proprietário da ATA de entrada, de cada ATA intermediária e da ATA de saída. Para novas integrações, use **tag 8 (`SwapBaseIn`)** ou **tag 9 (`SwapBaseOut`)** a menos que você tenha um motivo específico para chamar uma variante Legada.

## Instruções de swap atuais (recomendadas)

Estes são os pontos de entrada que o novo código deve usar. A estrutura de argumentos é a mesma que as variantes Legadas, mas `limit_prices` pode estar vazio.

### `SwapBaseIn` (tag 8)

Swap multi-hop com entrada exata. O chamador fixa `amount_in`; o roteador executa hop a hop e afirma que o montante final fica em ou acima de `minimum_amount_out`.

**Argumentos**

```
amount_in:            u64
minimum_amount_out:   u64
limit_prices:         VecDeque<u128>  // opcional; deque vazio significa sem verificação de preço CLMM por hop
```

**Contas**

```
[
  <user_input_ata> W S,         // assinante; saldo >= amount_in
  <user_intermediate_ata_1> W,  // um por hop intermediário
  ... <user_intermediate_ata_N> W,
  <user_output_ata> W,
  <token_program>,

  <pool_program_hop_1>,         // identifica qual família AMM o hop 1 é
  <pool_state_hop_1> W,
  ... <outras contas exigidas pelo programa do hop 1>,

  <pool_program_hop_2>,
  <pool_state_hop_2> W,
  ... <contas do hop 2>,

  ... [repita por hop]
]
```

A lista exata de contas por hop depende do programa AMM subjacente (AMM v4 / CPMM / CLMM / Stable). O roteador envia CPI em cada um por sua vez e valida que o ID do programa corresponde a um dos quatro programas suportados.

**Pré-condições**

* O chamador assina com `user_input_ata`.
* `user_input_ata.amount >= amount_in`.
* Cada ATA intermediária do usuário existe e é de propriedade do chamador.
* Se algum hop é CLMM e você quer aplicação vinculada a preço, forneça uma entrada de `limit_prices` por hop CLMM.

**Pós-condições**

* Saldo de `user_input_ata` diminuído por `amount_in`.
* Saldo de `user_output_ata` aumentado por ≥ `minimum_amount_out`.
* Cada ATA intermediária é deixada com mudança líquida zero (a rota consome tudo que produziu um hop anterior).

**Erros comuns**

* `ExceededSlippage` — saída final \< `minimum_amount_out`.
* `InvalidInput` — rota vazia, contas malformadas ou `pool_program` não suportado.
* `SqrtPriceX64` — o preço de um hop CLMM se moveu fora do limite de `limit_prices` fornecido (apenas quando `limit_prices` não está vazio).

***

### `SwapBaseOut` (tag 9)

Swap multi-hop com saída exata. O chamador fixa `amount_out`; o roteador afirma que a entrada real não excede `maximum_amount_in`.

**Argumentos**

```
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // opcional; deque vazio significa sem verificação de preço CLMM por hop
```

**Contas** — mesma estrutura que tag 8.

**Pré-condições**

* O chamador assina com `user_input_ata`; saldo `>= maximum_amount_in` (pior caso).
* Cada ATA intermediária e de saída existem.

**Pós-condições**

* `user_input_ata` diminuído pelo montante real necessário (≤ `maximum_amount_in`).
* `user_output_ata` aumentado por exatamente `amount_out`.

**Erros comuns**

* `ExceededSlippage` — entrada necessária excede `maximum_amount_in`.
* `InvalidInput`, `SqrtPriceX64` — como para tag 8.

***

## Instruções de swap legadas

Estas variantes mais antigas ainda podem ser chamadas no programa ao vivo e são documentadas aqui por completude. Prefira tag 8 / tag 9 para novo código; ambas as variantes Legadas abaixo exigem uma deque `limit_prices` não vazia mesmo quando nenhum hop CLMM está envolvido, o que as torna incômodas de usar.

### `SwapBaseInWithUserAccount` (tag 0)

Swap multi-hop com entrada exata, idêntico em forma à tag 8, mas com o requisito mais rigoroso de `limit_prices`.

**Argumentos**

```
amount_in:           u64
minimum_amount_out:  u64
limit_prices:        VecDeque<u128>  // obrigatório, não vazio
```

**Contas** — mesma forma que `SwapBaseIn` (tag 8). Todos os slots intermediários devem ser ATAs de propriedade do chamador.

**Pré-condições**

* O chamador assina com `user_input_ata`.
* `user_input_ata.amount >= amount_in`.
* Todas as ATAs intermediárias do usuário existem e são de propriedade do chamador.
* `limit_prices` é não vazio (uma entrada por hop CLMM; preencha com valores de placeholder se nenhum hop CLMM estiver envolvido).

**Pós-condições**

* Saldo de `user_input_ata` diminuído por `amount_in`.
* Saldo de `user_output_ata` aumentado por ≥ `minimum_amount_out`.

**Erros comuns**

* `ExceededSlippage`.
* `InvalidInput` — `limit_prices` vazio é rejeitado nesta variante Legada.
* `SqrtPriceX64`.

***

### `SwapBaseOutWithUserAccount` (tag 1)

Swap com saída exata, o equivalente Legado de `SwapBaseOut` (tag 9).

**Argumentos**

```
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // obrigatório, não vazio
```

**Contas** — mesma forma que tag 0 / tag 9.

**Pré-condições**

* O chamador assina com `user_input_ata`.
* `user_input_ata.amount >= maximum_amount_in`.
* Todas as ATAs intermediárias do usuário existem e são de propriedade do chamador.
* `limit_prices` é não vazio.

**Pós-condições**

* `user_input_ata` diminuído pelo montante real necessário (≤ `maximum_amount_in`).
* `user_output_ata` aumentado por exatamente `amount_out`.

**Erros comuns**

* `ExceededSlippage`.
* `InvalidInput`.
* `SqrtPriceX64`.

***

## Instruções de utilitário

### `CreateSyncNative` (tag 5)

Cria (se ausente) e sincroniza uma ATA wSOL em uma única etapa. Conveniente ao encapsular SOL junto com um swap.

**Argumentos**

```
amount: u64    // SOL a encapsular (lamports)
```

**Contas**

```
[
  <user_wsol_ata> W,            // ATA para wSOL; criada se ausente
  <user_native_account> W S,    // assinante; SOL é debitado daqui
  <wsol_mint>,
  <system_program>,
  <token_program>,
  <associated_token_program>,
]
```

**Efeito**

* Cria `user_wsol_ata` se ela ainda não existir.
* Transfere `amount` lamports do saldo SOL nativo do assinante para a ATA.
* Chama `SyncNative` na ATA para que seu saldo de token reflita os novos lamports.

**Erros comuns**

* `InvalidOwner` — o proprietário de `user_wsol_ata` não é o assinante.

***

### `CloseTokenAccount` (tag 6)

Fecha uma conta de token e retorna seu aluguel para a carteira de destino. Funciona em par com `CreateSyncNative`: após um swap de wSOL, chame `CloseTokenAccount` para recuperar o aluguel que apoiou a ATA wSOL.

**Argumentos** — nenhum.

**Contas**

```
[
  <token_account_to_close> W,
  <destination_for_rent> W,
  <owner> S,
  <token_program>,
]
```

**Efeito**

* Fecha `token_account_to_close`.
* Transfere o saldo de lamports isento de aluguel (\~0.00203928 SOL em mainnet para uma conta SPL Token vanilla) para `destination_for_rent`.
* A conta de token deve ter saldo de token zero.

**Erros comuns**

* `InvalidOwner` — o chamador não é o proprietário da ATA.
* Saldo da conta de token é não zero.

***

## Próximas etapas

* [`products/routing/code-demos`](/pt/products/routing/code-demos) — construindo cada uma destas instruções em TypeScript.
* [`products/routing/accounts`](/pt/products/routing/accounts) — chaves de dispatch por AMM e layout de conta por hop.
* [`reference/error-codes`](/pt/reference/error-codes) — lista completa de `RouteError`.