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

# Contas de Farm / Staking

> FarmState, UserStake / Ledger, vaults de recompensas e as PDAs de autoridade — layouts e seeds de PDA para farm v3, v5 e v6.

<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/farm-staking/accounts)
</Info>

<Info>
  **Três programas, três schemas.** Farm v3, v5 e v6 são programas separados com layouts de estado distintos. Esta página documenta cada um lado a lado. Na prática, a maioria das novas integrações visa v6; v3 e v5 são somente leitura para a maioria dos integradores (staking já aconteceu ali há muito tempo e os pools estão em desativação).
</Info>

## Inventário de contas (por farm, qualquer versão)

| Conta                                   | Owner                    | Propósito                                                                                |
| --------------------------------------- | ------------------------ | ---------------------------------------------------------------------------------------- |
| `FarmState`                             | Programa Farm (v3/v5/v6) | Estado raiz: mint de staking, total de stake, fluxos de recompensas.                     |
| `farm_authority`                        | Programa Farm            | PDA que possui o vault de staking e os vaults de recompensas.                            |
| `staking_vault`                         | SPL Token                | Contém LP em stake (ou qualquer que seja o mint de staking).                             |
| `reward_vault_{i}`                      | SPL Token                | Contém o orçamento não distribuído para o fluxo de recompensas `i`. Um por fluxo.        |
| `UserStake` (v3/v5) / `UserLedger` (v6) | Programa Farm            | Ledger por `(farm, user)`: quantidade em stake + snapshot de reward-per-share por fluxo. |

O SDK retorna o conjunto completo em `raydium.farm.getFarmById`. Para farms de terceiros arbitrárias, o endpoint de API `GET https://api-v3.raydium.io/main/farms/info?ids=<FARM_ID>` também os retorna.

## Layout `FarmState` — v6

v6 é a versão atual. Sua estrutura de conta é a mais genérica.

```rust theme={null}
// programs/farm_v6/src/state/farm.rs (abridged)
pub struct FarmState {
    pub state: u64,                // bitfield: 0 = live, 1 = paused, ...
    pub nonce: u64,                 // bump for farm_authority
    pub creator: Pubkey,            // original creator (can add rewards / transfer admin)
    pub staking_mint: Pubkey,
    pub staking_vault: Pubkey,
    pub staking_token_program: Pubkey, // SPL Token or Token-2022
    pub lp_mint_decimals: u8,
    pub reward_period_len: u64,     // minimum duration between SetRewards edits
    pub reward_period_min: u64,
    pub total_staked: u64,
    pub reward_info_count: u8,
    pub _reserved: [u8; ...],
    pub reward_infos: [RewardInfo; 5], // up to 5 reward streams
}

pub struct RewardInfo {
    pub reward_state: u8,           // 0 = unused, 1 = running, 2 = ended
    pub open_time: u64,             // start_time
    pub end_time: u64,
    pub last_update_time: u64,
    pub emission_per_second_x64: u128, // Q64.64 fixed-point rate
    pub reward_total_emissioned: u64,   // sum of emissions so far
    pub reward_claimed: u64,            // sum paid out to stakers
    pub reward_vault: Pubkey,
    pub reward_mint: Pubkey,
    pub reward_sender: Pubkey,          // who deposited the budget; can top up
    pub reward_token_program: Pubkey,   // SPL or Token-2022
    pub reward_per_share_x64: u128,     // Q64.64 counter
}
```

Campos relevantes para integradores:

* **`staking_mint`, `staking_vault`** — o que é depositado em stake e onde fica armazenado.
* **`total_staked`** — total atual. Necessário para calcular APR: `reward_per_second × 86400 / total_staked`.
* **`reward_infos[i].emission_per_second_x64`** — a taxa em Q64.64. Divida por `2^64` para obter a contagem real de tokens por segundo.
* **`reward_infos[i].open_time` / `end_time`** — para exibições na UI "X dias restantes".
* **`reward_infos[i].reward_per_share_x64`** — o contador do qual o `UserLedger` deduz.

## Layout `FarmState` — v5

```rust theme={null}
pub struct FarmStateV5 {
    pub state: u64,
    pub nonce: u64,
    pub lp_vault: Pubkey,            // aka staking_vault
    pub reward_vaults: [Pubkey; 2],
    pub owner: Pubkey,
    pub reward_mints: [Pubkey; 2],
    pub reward_total_emissioned: [u64; 2],
    pub reward_claimed: [u64; 2],
    pub reward_per_second: [u64; 2],  // integer, not fixed-point
    pub reward_open_time: [u64; 2],
    pub reward_end_time: [u64; 2],
    pub reward_per_share: [u128; 2],  // Q56.8 or similar; check program source
    pub total_staked: u64,
    pub last_slot: u64,               // v5 updates per-slot on mainnet
    pub _reserved: [u8; 256],
}
```

Diferenças em relação a v6:

* **Por slot, não por segundo.** O loop de atualização v5 executa em slots em vez do relógio de parede. O SDK normaliza isso para "por segundo" na UI, mas on-chain a unidade é slots.
* **Taxa de emissão inteira.** `reward_per_second` é `u64`. Isso limita a taxa mínima expressável a 1 unidade por segundo, o que é muito grosseiro para fluxos de baixa emissão em mints de 9 casas decimais. v6 corrigiu isso com a taxa Q64.64.
* **Sem `reward_sender`.** Em v5, o owner é o remetente implícito; apenas `owner` pode aumentar o orçamento.

## Layout `FarmState` — v3

```rust theme={null}
pub struct FarmStateV3 {
    pub state: u64,
    pub nonce: u64,
    pub lp_vault: Pubkey,
    pub reward_vault: Pubkey,          // single reward
    pub owner: Pubkey,
    pub reward_mint: Pubkey,
    pub reward_total_emissioned: u64,
    pub reward_claimed: u64,
    pub reward_per_slot: u64,
    pub reward_per_share: u128,
    pub total_staked: u64,
    pub last_slot: u64,
    pub _reserved: [u8; 256],
}
```

Recompensa única. Baseado em slots. A geração de programa mais antiga, mantida viva para os farms RAY-USDC e SOL-USDC que antecedem v5.

## `UserLedger` (v6) / `UserStake` (v5/v3)

Estado por usuário, uma conta por par `(farm, user)`. PDA com seed:

```ts theme={null}
// v6
const [ledgerPda] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer(), user.toBuffer(), Buffer.from("user_stake_info_v2")],
  FARM_V6_PROGRAM_ID,
);

// v5
const [stakePda] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer(), user.toBuffer(), Buffer.from("user_stake_info")],
  FARM_V5_PROGRAM_ID,
);

// v3
const [stakePda] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer(), user.toBuffer(), Buffer.from("staker_info")],
  FARM_V3_PROGRAM_ID,
);
```

(As strings de seed são os valores realmente usados pelo SDK; as versões de programa historicamente os variaram. Verifique contra a fonte v6 para qualquer coisa crítica em segurança.)

```rust theme={null}
// v6
pub struct UserLedger {
    pub version: u64,
    pub farm_id: Pubkey,
    pub owner: Pubkey,
    pub deposited: u64,                          // current stake
    pub reward_debts: [u128; 5],                 // snapshot of reward_per_share_x64 × deposited
}
```

A dívida por fluxo é o offset de contabilidade descrito na visão geral:

```
pending_for_stream_i = deposited × reward_per_share_x64[i] / 2^64  − reward_debts[i]
```

Após cada `Deposit`, `Withdraw` ou `Harvest`, a dívida é redefinida para o `deposited × reward_per_share_x64[i] / 2^64` atual.

## PDAs de autoridade

```ts theme={null}
// v6
const [farmAuthorityV6] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer()],
  FARM_V6_PROGRAM_ID,
);

// v5
const [farmAuthorityV5] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer()],
  FARM_V5_PROGRAM_ID,
);

// v3
const [farmAuthorityV3] = PublicKey.findProgramAddressSync(
  [farmId.toBuffer()],
  FARM_V3_PROGRAM_ID,
);
```

Todas as três versões derivam a autoridade do farm por farm com uma única seed. Essa PDA é a autoridade no vault de staking e em cada vault de recompensas. Ela assina cada transferência que o farm realiza.

## Vaults

Os vaults de staking e recompensas são contas padrão de SPL Token cujo `owner` é a PDA de autoridade do farm. Os endereços são armazenados em `FarmState` — não re-derive; leia do estado. As autoridades de congelamento devem estar desabilitadas no mint de staking para v5/v6 (o programa verifica).

Notas sobre Token-2022:

* **v3**: Apenas SPL Token.
* **v5**: Apenas SPL Token.
* **v6**: Suporta Token-2022 em mints de staking e recompensas, controlado pelos campos `staking_token_program` / `reward_token_program`. As taxas de transferência em mints de recompensas Token-2022 são cobradas na emissão (vault → usuário).

## Observação e APR

Farms não armazenam APR on-chain. Para calcular:

```
annualized_rewards_value_usd = reward_per_second × 86400 × 365 × reward_usd_price
tvl_usd                     = total_staked / 10^decimals × staking_mint_usd_price
apr                         = annualized_rewards_value_usd / tvl_usd
```

Os consumidores normalmente obtêm `staking_mint_usd_price` do pool ao qual o LP pertence (via `api-v3.raydium.io/pools/info/ids`) e `reward_usd_price` de qualquer oráculo de preço.

## Próximos passos

* [`products/farm-staking/instructions`](/pt/products/farm-staking/instructions) — referência de instruções por versão.
* [`products/farm-staking/code-demos`](/pt/products/farm-staking/code-demos) — staking, harvesting e criação de farms via SDK.
* [`reference/program-addresses`](/pt/reference/program-addresses) — todos os três IDs de programa.

Fontes:

* [Módulo `Farm` do Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2)
* O código-fonte do programa Farm v6 não é publicado como um repositório independente no momento; o IDL está incluído no SDK em [`raydium-io/raydium-sdk-V2`](https://github.com/raydium-io/raydium-sdk-V2) sob `src/raydium/farm/`.