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

# Farm- / Staking-Konten

> FarmState, UserStake / Ledger, Reward-Vaults und die Authority-PDAs — Layouts und PDA-Seeds für Farm v3, v5 und v6.

<Info>
  **Diese Seite wurde mit KI automatisch übersetzt. Maßgeblich ist stets die englische Version.**

  [Englische Version ansehen →](/products/farm-staking/accounts)
</Info>

<Info>
  **Drei Programme, drei Schemas.** Farm v3, v5 und v6 sind separate Programme mit separaten State-Layouts. Diese Seite dokumentiert jede Version nebeneinander. In der Praxis zielen die meisten neuen Integrationen auf v6 ab; v3 und v5 sind für die meisten Integratoren schreibgeschützt (Staking fand dort vor langer Zeit statt und die Pools laufen aus).
</Info>

## Kontobestand (pro Farm, beliebige Version)

| Konto                                   | Eigentümer               | Zweck                                                                                       |
| --------------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------- |
| `FarmState`                             | Farm-Programm (v3/v5/v6) | Wurzel-State: Staking-Mint, insgesamt gestaked, Reward-Streams.                             |
| `farm_authority`                        | Farm-Programm            | PDA, die den Staking-Vault und die Reward-Vaults besitzt.                                   |
| `staking_vault`                         | SPL Token                | Hält gestaked LP (oder was immer der Staking-Mint ist).                                     |
| `reward_vault_{i}`                      | SPL Token                | Hält das unverteilte Budget für Reward-Stream `i`. Einer pro Stream.                        |
| `UserStake` (v3/v5) / `UserLedger` (v6) | Farm-Programm            | Pro-`(farm, user)` Ledger: gestaked Betrag + Schnappschuss der Reward-pro-Share pro Stream. |

Das SDK gibt den vollständigen Satz auf `raydium.farm.getFarmById` zurück. Für beliebige Third-Party-Farms liefert auch der API-Endpunkt `GET https://api-v3.raydium.io/main/farms/info?ids=<FARM_ID>` diese zurück.

## `FarmState`-Layout — v6

v6 ist die aktuelle Version. Ihre Kontostruktur ist die allgemeinste.

```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
}
```

Für Integratoren relevante Felder:

* **`staking_mint`, `staking_vault`** — was gestaked wird und wo es sitzt.
* **`total_staked`** — aktuell gesamt. Erforderlich zur Berechnung der APR: `reward_per_second × 86400 / total_staked`.
* **`reward_infos[i].emission_per_second_x64`** — die Q64.64-Rate. Durch `2^64` teilen für die echte Token-Anzahl pro Sekunde.
* **`reward_infos[i].open_time` / `end_time`** — für UI-Anzeigen „X Tage verbleibend".
* **`reward_infos[i].reward_per_share_x64`** — der Zähler, dem das `UserLedger` entgegenrechnet.

## `FarmState`-Layout — 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],
}
```

Unterschiede zu v6:

* **Pro Slot, nicht pro Sekunde.** v5's Update-Schleife läuft auf Slots statt auf der Wanduhr. Das SDK normalisiert dies in der UI in „pro Sekunde", aber on-chain ist die Einheit Slots.
* **Integer-Emissionsrate.** `reward_per_second` ist `u64`. Dies begrenzt die minimal ausdrückbare Rate auf 1 Einheit pro Sekunde, was zu grob für Low-Emission-Streams auf 9-Dezimal-Mints ist. v6 behob dies mit der Q64.64-Rate.
* **Kein `reward_sender`**. In v5 ist der Eigentümer der implizite Absender; nur `owner` kann aufstocken.

## `FarmState`-Layout — 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],
}
```

Single-Reward. Slot-basiert. Die älteste Programmgeneration, am Leben erhalten für die RAY-USDC und SOL-USDC Farms, die v5 vorausgehen.

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

Pro-Benutzer-State, ein Konto pro `(farm, user)` Paar. Seeded PDA:

```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,
);
```

(Seed-Strings sind die Werte, die tatsächlich vom SDK verwendet werden; Programmversionen haben sie historisch unterschiedlich gestaltet. Überprüfen Sie gegen die v6-Quelle für alles Sicherheitskritisches.)

```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
}
```

Die Pro-Stream-Schuld ist der Accounting-Offset, der in der Übersicht beschrieben wird:

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

Nach jedem `Deposit`, `Withdraw` oder `Harvest` wird die Schuld auf den aktuellen `deposited × reward_per_share_x64[i] / 2^64` zurückgesetzt.

## Authority-PDAs

```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,
);
```

Alle drei Versionen leiten die Farm-Authority pro Farm mit einem einzelnen Seed ab. Diese PDA ist die Authority auf dem Staking-Vault und auf jedem Reward-Vault. Sie signiert jeden Transfer, den die Farm vornimmt.

## Vaults

Staking- und Reward-Vaults sind Standard-SPL-Token-Konten, deren `owner` die Farm-Authority-PDA ist. Adressen werden auf `FarmState` gespeichert — nicht neu ableiten; aus dem State lesen. Freeze-Authorities müssen auf dem Staking-Mint für v5/v6 deaktiviert werden (das Programm überprüft dies).

Token-2022-Hinweise:

* **v3**: Nur SPL Token.
* **v5**: Nur SPL Token.
* **v6**: Unterstützt Token-2022 auf Staking- und Reward-Mints, gated auf `staking_token_program` / `reward_token_program` Felder. Transfergebühren auf Token-2022 Reward-Mints werden beim Emit berechnet (Vault → Benutzer).

## Beobachtung und APR

Farms speichern keine APR on-chain. Zur Berechnung:

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

Consumer ziehen typischerweise `staking_mint_usd_price` aus dem Pool, zu dem die LP gehört (über `api-v3.raydium.io/pools/info/ids`) und `reward_usd_price` aus einem beliebigen Price-Oracle.

## Nächste Schritte

* [`products/farm-staking/instructions`](/de/products/farm-staking/instructions) — Pro-Version-Anweisungsreferenz.
* [`products/farm-staking/code-demos`](/de/products/farm-staking/code-demos) — Staking, Harvesting und Farm-Erstellung über das SDK.
* [`reference/program-addresses`](/de/reference/program-addresses) — alle drei Programm-IDs.

Quellen:

* [Raydium SDK v2 `Farm` module](https://github.com/raydium-io/raydium-sdk-V2)
* Die Farm v6 Programmquelle wird derzeit nicht als eigenständiges Repo veröffentlicht; die IDL ist im SDK unter [`raydium-io/raydium-sdk-V2`](https://github.com/raydium-io/raydium-sdk-V2) unter `src/raydium/farm/` gebündelt.