Passer au contenu 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.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.Voir la version anglaise →
Trois programmes, trois schémas. Farm v3, v5 et v6 sont des programmes distincts avec des layouts d’état différents. Cette page documente chacun côte à côte. En pratique, la plupart des nouvelles intégrations ciblent v6 ; v3 et v5 sont en lecture seule pour la plupart des intégrateurs (le staking a déjà eu lieu il y a longtemps et les pools sont en phase d’arrêt).

​
Inventaire des comptes (par farm, quelle que soit la version)

ComptePropriétaireObjectif
FarmStateProgramme Farm (v3/v5/v6)État racine : mint de staking, total staké, flux de récompenses.
farm_authorityProgramme FarmPDA qui possède le vault de staking et les vaults de récompenses.
staking_vaultSPL TokenContient le LP staké (ou quel que soit le mint de staking).
reward_vault_{i}SPL TokenContient le budget non distribué pour le flux de récompenses i. Un par flux.
UserStake (v3/v5) / UserLedger (v6)Programme FarmLedger par (farm, user) : montant staké + snapshot de la récompense par partage par flux.
Le SDK retourne l’ensemble complet sur raydium.farm.getFarmById. Pour les farms tiers arbitraires, le point de terminaison API GET https://api-v3.raydium.io/main/farms/info?ids=<FARM_ID> les retourne également.

​
Layout FarmState — v6

v6 est la version actuelle. Sa structure de compte est la plus générale. 
// 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
}
Champs pour les intégrateurs :
  • staking_mint, staking_vault — ce qui est staké et où il se trouve.
  • total_staked — total actuel. Requis pour calculer l’APR : reward_per_second × 86400 / total_staked.
  • reward_infos[i].emission_per_second_x64 — le taux Q64.64. Divisez par 2^64 pour obtenir le vrai nombre de tokens par seconde.
  • reward_infos[i].open_time / end_time — pour les affichages UI « X jours restants ».
  • reward_infos[i].reward_per_share_x64 — le compteur sur lequel le UserLedger accorde une dette.

​
Layout FarmState — v5

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],
}
Différences par rapport à v6 :
  • Par slot, et non par seconde. La boucle de mise à jour de v5 s’exécute sur les slots plutôt que sur l’horloge. Le SDK normalise ceci en « par seconde » pour l’interface utilisateur, mais on-chain l’unité est les slots.
  • Taux d’émission entier. reward_per_second est u64. Cela limite le taux minimum exprimable à 1 unité par seconde, ce qui est trop grossier pour les flux à faible émission sur les mints à 9 décimales. v6 a corrigé cela avec le taux Q64.64.
  • Pas de reward_sender. Sur v5, le propriétaire est l’expéditeur implicite ; seul owner peut reconstituer les fonds.

​
Layout FarmState — v3

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],
}
Une seule récompense. Basé sur les slots. La génération de programme la plus ancienne, maintenue en vie pour les farms RAY-USDC et SOL-USDC qui précèdent v5.

​
UserLedger (v6) / UserStake (v5/v3)

État par utilisateur, un compte par paire (farm, user). PDA seedé : 
// 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,
);
(Les chaînes de seed sont les valeurs réellement utilisées par le SDK ; les versions de programme les ont historiquement variées. Vérifiez par rapport à la source v6 pour tout ce qui est critique pour la sécurité.) 
// 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
}
La dette par flux est l’offset comptable décrit dans l’aperçu : 
pending_for_stream_i = deposited × reward_per_share_x64[i] / 2^64  − reward_debts[i]
Après chaque Deposit, Withdraw ou Harvest, la dette est réinitialisée à deposited × reward_per_share_x64[i] / 2^64 actuel.

​
PDAs d’autorité

// 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,
);
Toutes les trois versions dérivent l’autorité farm par farm avec une seule seed. Ce PDA est l’autorité sur le vault de staking et sur chaque vault de récompenses. Il signe chaque transfert effectué par la farm.

​
Vaults

Les vaults de staking et de récompenses sont des comptes SPL Token standard dont le owner est la PDA d’autorité de la farm. Les adresses sont stockées sur FarmState — ne les re-dérivez pas ; lisez-les à partir de l’état. Les autorités de gel doivent être désactivées sur le mint de staking pour v5/v6 (le programme le vérifie). Notes sur Token-2022 :
  • v3 : SPL Token uniquement.
  • v5 : SPL Token uniquement.
  • v6 : Prend en charge Token-2022 sur les mints de staking et de récompenses, contrôlé par les champs staking_token_program / reward_token_program. Les frais de transfert sur les mints de récompenses Token-2022 sont prélevés à l’émission (vault → utilisateur).

​
Observation et APR

Les farms ne stockent pas l’APR on-chain. Pour le calculer : 
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
Les consommateurs extraient généralement staking_mint_usd_price du pool auquel appartient le LP (via api-v3.raydium.io/pools/info/ids) et reward_usd_price de tout oracle de prix.

​
Où aller ensuite

Sources :