> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Staking programmatique Solana avec Helius SDK

> Créez des expériences de staking Solana transparentes avec le SDK Helius. Guide complet de la configuration au retrait avec intégration d'un validateur à 0 % de commission.

<Info>
  **Validateur sans commission**: Stakez avec le validateur Helius et conservez 100 % de vos récompenses de staking avec notre taux de commission de 0 %.
</Info>

## Aperçu rapide

Le SDK Helius fournit des méthodes simples pour gérer le cycle de vie complet du staking SOL de manière programmatique. Parfait pour construire des interfaces de staking, des protocoles DeFi, ou des stratégies de staking automatisées.

<CardGroup cols={3}>
  <Card title="Créer & Déléguer" icon="plus">
    Créez de nouveaux comptes de staking et déléguez aux validateurs en une seule transaction
  </Card>

  <Card title="Surveiller & Gérer" icon="chart-line">
    Suivez les récompenses, vérifiez le statut, et gérez les comptes de staking existants
  </Card>

  <Card title="Retirer & Récupérer" icon="money-bill">
    Désactivez les mises et retirez le SOL après les périodes de refroidissement
  </Card>
</CardGroup>

## Installation & Configuration

<CodeGroup>
  ```bash npm theme={"system"}
  npm install helius-sdk @solana/web3.js bs58
  ```

  ```bash yarn   theme={"system"}
  yarn add helius-sdk @solana/web3.js bs58
  ```

  ```bash pnpm theme={"system"}
  pnpm add helius-sdk @solana/web3.js bs58
  ```
</CodeGroup>

<CodeGroup>
  ```typescript Setup theme={"system"}
  import { Helius } from 'helius-sdk';
  import { Keypair, Transaction } from '@solana/web3.js';
  import bs58 from 'bs58';

  // Initialize Helius client
  const helius = new Helius('YOUR_API_KEY');

  // Your wallet keypair (load from your secure storage)
  const payer = Keypair.fromSecretKey(/* your secret key */);
  ```
</CodeGroup>

## Notions de base sur le staking

<AccordionGroup>
  <Accordion title="Comment fonctionne le staking Solana">
    **Compte de staking**: Un compte spécial qui verrouille le SOL et le délègue à un validateur. Chaque compte de staking pointe vers exactement un validateur.

    **Récompenses**: Les validateurs gagnent des récompenses pour sécuriser le réseau. Ces récompenses sont distribuées à tous les comptes de staking délégués à ce validateur.

    **Cycle de vie**: Créer → Déléguer → Gagner des récompenses → Désactiver → Retirer
  </Accordion>

  <Accordion title="Pourquoi choisir le validateur Helius">
    * **0% de commission**: Conservez 100 % de vos récompenses de staking
    * **Haute performance**: Production de blocs fiable et temps d'arrêt minimal
    * **Intégration facile**: Optimisé pour le SDK Helius avec des aides intégrées
  </Accordion>

  <Accordion title="Synchronisation & Époques">
    * **Activation**: Les mises deviennent actives au début de la prochaine époque (\~2 jours)
    * **Désactivation**: Prend effet à la fin de l'époque actuelle
    * **Refroidissement**: Les mises désactivées peuvent être retirées immédiatement après la fin de l'époque
  </Accordion>
</AccordionGroup>

## Pour commencer

<Tabs>
  <Tab title="Démarrage rapide">
    Stakez du SOL en seulement 3 lignes de code :

    ```typescript theme={"system"}
    // 1. Create the staking transaction
    const { serializedTx, stakeAccountPubkey } = 
      await helius.rpc.createStakeTransaction(payer.publicKey, 1.5);

    // 2. Sign and send
    const tx = Transaction.from(bs58.decode(serializedTx));
    tx.partialSign(payer);
    const signature = await helius.connection.sendRawTransaction(tx.serialize());

    console.log(`Staked! Transaction: ${signature}`);
    console.log(`Stake Account: ${stakeAccountPubkey}`);
    ```

    <Info>
      Le SDK gère automatiquement le calcul du loyer et la création de comptes de staking. Le paramètre `1.5` est le montant en SOL que vous souhaitez mettre en jeu.
    </Info>
  </Tab>

  <Tab title="Exemple complet">
    Mise en œuvre complète du staking avec gestion des erreurs :

    ```typescript theme={"system"}
    async function stakeSOL(amountInSol: number) {
      try {
        // Create staking transaction
        const { serializedTx, stakeAccountPubkey } = 
          await helius.rpc.createStakeTransaction(payer.publicKey, amountInSol);
        
        // Deserialize and sign transaction
        const transaction = Transaction.from(bs58.decode(serializedTx));
        transaction.partialSign(payer);
        
        // Send transaction
        const signature = await helius.connection.sendRawTransaction(
          transaction.serialize(),
          { 
            skipPreflight: false,
            preflightCommitment: 'confirmed'
          }
        );
        
        // Wait for confirmation
        await helius.connection.confirmTransaction(signature, 'confirmed');
        
        return {
          signature,
          stakeAccount: stakeAccountPubkey,
          amount: amountInSol
        };
        
      } catch (error) {
        console.error('Staking failed:', error);
        throw error;
      }
    }

    // Usage
    const result = await stakeSOL(2.5);
    console.log(`Successfully staked ${result.amount} SOL`);
    ```
  </Tab>
</Tabs>

## Référence des méthodes SDK

<AccordionGroup>
  <Accordion title="createStakeTransaction(owner, amount)">
    Crée une transaction de staking complète qui peut être signée et envoyée.

    **Paramètres :**

    * `owner` (PublicKey): Le portefeuille qui possédera le compte de staking
    * `amount` (number): Montant de SOL à staker

    **Retourne :**

    ```typescript theme={"system"}
    {
      serializedTx: string,        // Base58 encoded transaction
      stakeAccountPubkey: string   // New stake account address
    }
    ```

    **Exemple :**

    ```typescript theme={"system"}
    const result = await helius.rpc.createStakeTransaction(
      payer.publicKey, 
      1.5  // 1.5 SOL
    );
    ```
  </Accordion>

  <Accordion title="getStakeInstructions(owner, amount)">
    Renvoie uniquement les instructions pour le staking (utile pour la construction de transactions personnalisées).

    **Retourne :**

    ```typescript theme={"system"}
    {
      instructions: TransactionInstruction[],
      stakeAccount: Keypair
    }
    ```

    **Exemple :**

    ```typescript theme={"system"}
    const { instructions } = await helius.rpc.getStakeInstructions(
      payer.publicKey, 
      1.5
    );

    // Use with Smart Transactions
    const signature = await helius.rpc.sendSmartTransaction(
      instructions, 
      [payer]
    );
    ```
  </Accordion>

  <Accordion title="getHeliusStakeAccounts(wallet)">
    Récupère tous les comptes de staking délégués au validateur Helius pour un portefeuille.

    **Exemple :**

    ```typescript theme={"system"}
    const accounts = await helius.rpc.getHeliusStakeAccounts(
      payer.publicKey.toBase58()
    );

    accounts.forEach(account => {
      const delegation = account.account.data.parsed.info.stake.delegation;
      console.log(`Account: ${account.pubkey}`);
      console.log(`Stake: ${delegation.stake / LAMPORTS_PER_SOL} SOL`);
    });
    ```
  </Accordion>

  <Accordion title="createUnstakeTransaction(owner, stakeAccount)">
    Crée une transaction pour désactiver (commencer le désengagement) un compte de staking.

    **Exemple :**

    ```typescript theme={"system"}
    const tx = await helius.rpc.createUnstakeTransaction(
      payer.publicKey,
      stakeAccountPubkey
    );

    const transaction = Transaction.from(bs58.decode(tx));
    transaction.partialSign(payer);
    await helius.connection.sendRawTransaction(transaction.serialize());
    ```
  </Accordion>

  <Accordion title="getWithdrawableAmount(stakeAccount, includeRent?)">
    Vérifiez combien de SOL peuvent être retirés d'un compte de staking désactivé.

    **Paramètres :**

    * `includeRent` (boolean): Indiquer si le montant exonéré de loyer doit être inclus

    **Exemple :**

    ```typescript theme={"system"}
    const available = await helius.rpc.getWithdrawableAmount(stakeAccountPubkey);
    const total = await helius.rpc.getWithdrawableAmount(stakeAccountPubkey, true);

    console.log(`Available now: ${available / LAMPORTS_PER_SOL} SOL`);
    console.log(`Total balance: ${total / LAMPORTS_PER_SOL} SOL`);
    ```
  </Accordion>

  <Accordion title="createWithdrawTransaction(owner, stakeAccount, destination, amount)">
    Crée une transaction pour retirer du SOL d'un compte de staking désactivé.

    **Exemple :**

    ```typescript theme={"system"}
    const tx = await helius.rpc.createWithdrawTransaction(
      payer.publicKey,
      stakeAccountPubkey,
      destinationPubkey,
      withdrawAmount  // in lamports
    );
    ```
  </Accordion>
</AccordionGroup>

## Workflow complet de staking

<Steps>
  <Step title="Créer et Déléguer">
    ```typescript theme={"system"}
    // Stake 2 SOL to Helius validator
    const { serializedTx, stakeAccountPubkey } = 
      await helius.rpc.createStakeTransaction(payer.publicKey, 2.0);

    const tx = Transaction.from(bs58.decode(serializedTx));
    tx.partialSign(payer);

    const signature = await helius.connection.sendRawTransaction(tx.serialize());
    console.log(`Stake created: ${stakeAccountPubkey}`);
    ```
  </Step>

  <Step title="Surveillez vos mises">
    ```typescript theme={"system"}
    // Get all your Helius stake accounts
    const accounts = await helius.rpc.getHeliusStakeAccounts(
      payer.publicKey.toBase58()
    );

    console.log(`You have ${accounts.length} active stake accounts`);

    accounts.forEach((account, index) => {
      const info = account.account.data.parsed.info;
      const delegation = info.stake.delegation;
      
      console.log(`Stake ${index + 1}:`);
      console.log(`  Amount: ${delegation.stake / LAMPORTS_PER_SOL} SOL`);
      console.log(`  Activated: Epoch ${delegation.activationEpoch}`);
      console.log(`  Status: ${info.meta.lockup.unixTimestamp === 0 ? 'Active' : 'Locked'}`);
    });
    ```
  </Step>

  <Step title="Désactivation (commencer le désengagement)">
    ```typescript theme={"system"}
    // Begin the unstaking process
    const unstakeTx = await helius.rpc.createUnstakeTransaction(
      payer.publicKey,
      stakeAccountPubkey
    );

    const tx = Transaction.from(bs58.decode(unstakeTx));
    tx.partialSign(payer);

    await helius.connection.sendRawTransaction(tx.serialize());
    console.log('Deactivation started. Will be withdrawable next epoch.');
    ```
  </Step>

  <Step title="Retirer du SOL">
    ```typescript theme={"system"}
    // Check withdrawable amount
    const withdrawable = await helius.rpc.getWithdrawableAmount(
      stakeAccountPubkey, 
      true  // include rent
    );

    if (withdrawable > 0) {
      // Create withdrawal instruction
      const withdrawInstruction = helius.rpc.getWithdrawInstruction(
        payer.publicKey,
        stakeAccountPubkey,
        payer.publicKey,  // withdraw to same wallet
        withdrawable
      );
      
      // Send using Smart Transactions for better reliability
      const signature = await helius.rpc.sendSmartTransaction(
        [withdrawInstruction], 
        [payer]
      );
      
      console.log(`Withdrawn ${withdrawable / LAMPORTS_PER_SOL} SOL`);
    }
    ```
  </Step>
</Steps>

## Modèles avancés

<Tabs>
  <Tab title="Intégration au navigateur">
    Pour les applications de navigateur utilisant des adaptateurs de portefeuille :

    ```typescript theme={"system"}
    // Get instructions instead of full transaction
    const { instructions, stakeAccount } = await helius.rpc.getStakeInstructions(
      wallet.publicKey,
      stakeAmount
    );

    // Let the wallet handle transaction building and signing
    const transaction = new Transaction().add(...instructions);

    // Sign with wallet adapter
    const signature = await wallet.sendTransaction(transaction, connection);

    console.log(`Stake account: ${stakeAccount.publicKey.toBase58()}`);
    ```
  </Tab>

  <Tab title="Opérations par lots">
    Stakez pour plusieurs portefeuilles efficacement :

    ```typescript theme={"system"}
    async function batchStake(wallets: Keypair[], amount: number) {
      const promises = wallets.map(async (wallet) => {
        try {
          const { serializedTx, stakeAccountPubkey } = 
            await helius.rpc.createStakeTransaction(wallet.publicKey, amount);
          
          const tx = Transaction.from(bs58.decode(serializedTx));
          tx.partialSign(wallet);
          
          return helius.connection.sendRawTransaction(tx.serialize());
        } catch (error) {
          console.error(`Failed to stake for ${wallet.publicKey.toBase58()}:`, error);
          return null;
        }
      });
      
      const results = await Promise.allSettled(promises);
      const successful = results.filter(r => r.status === 'fulfilled').length;
      
      console.log(`Successfully staked for ${successful}/${wallets.length} wallets`);
    }
    ```
  </Tab>

  <Tab title="Transactions intelligentes">
    Utilisez les transactions intelligentes pour une meilleure fiabilité et optimisation :

    ```typescript theme={"system"}
    // Get individual instructions
    const { instructions } = await helius.rpc.getStakeInstructions(
      payer.publicKey,
      2.5
    );

    // Send with Smart Transaction features:
    // - Automatic priority fee optimization
    // - Retry logic with backoff
    // - Better error handling
    const signature = await helius.rpc.sendSmartTransaction(
      instructions,
      [payer],
      {
        skipPreflight: false,
        maxRetries: 3
      }
    );

    console.log(`Smart transaction sent: ${signature}`);
    ```
  </Tab>
</Tabs>

## Notes importantes

<Warning>
  **Synchronisation des époques**: Les époques Solana durent \~2 jours. Les mises s'activent au début de l'époque suivante, et la désactivation prend effet à la fin de l'époque actuelle.
</Warning>

<Note>
  **Considérations sur le loyer**: Les comptes de staking nécessitent des réserves exemptes de loyer (\~0.00228 SOL). Retirer le solde complet ferme le compte.
</Note>

<Tip>
  **Portefeuilles matériels**: Les utilisateurs verront deux demandes de signature - une pour le compte de staking (pré-signée) et une pour le payeur des frais. Concevez votre UX en conséquence.
</Tip>

## Référence rapide

Besoin d'un rappel rapide ? Voici les méthodes essentielles :

```typescript theme={"system"}
// Stake SOL
await helius.rpc.createStakeTransaction(owner, amountInSol);

// Check your stakes  
await helius.rpc.getHeliusStakeAccounts(ownerAddress);

// Start unstaking
await helius.rpc.createUnstakeTransaction(owner, stakeAccount);

// Check withdrawable amount
await helius.rpc.getWithdrawableAmount(stakeAccount, includeRent);

// Withdraw SOL
helius.rpc.getWithdrawInstruction(owner, stakeAccount, destination, amount);
```

## Prochaines étapes

<CardGroup cols={2}>
  <Card title="Documentation Helius SDK" icon="code" href="https://github.com/helius-labs/helius-sdk">
    Référence complète du SDK avec toutes les méthodes disponibles
  </Card>

  <Card title="Transactions intelligentes" icon="bolt" href="/docs/fr/sending-transactions/optimizing-transactions">
    Optimisez vos transactions avec des frais prioritaires et une logique de reprise
  </Card>

  <Card title="Rejoindre Discord" icon="discord" href="https://discord.com/invite/6GXdee3gBj">
    Obtenez de l'aide de notre communauté de développeurs
  </Card>

  <Card title="Tableau de bord du validateur" icon="chart-bar" href="https://www.validators.app/validators/EKgWgpJY5BtX7TeJfhKbqcJT7gzLKFFtj7cjX1XY6CxA">
    Surveillez les performances et les récompenses du validateur Helius
  </Card>
</CardGroup>