Staking programmatique Solana avec Helius SDK

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

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.

Créer & Déléguer

Créez de nouveaux comptes de staking et déléguez aux validateurs en une seule transaction

Surveiller & Gérer

Suivez les récompenses, vérifiez le statut, et gérez les comptes de staking existants

Retirer & Récupérer

Désactivez les mises et retirez le SOL après les périodes de refroidissement

Installation & Configuration

npm install helius-sdk @solana/web3.js bs58

yarn add helius-sdk @solana/web3.js bs58

pnpm add helius-sdk @solana/web3.js bs58

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 */);

Notions de base sur le staking

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

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

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

Pour commencer

Démarrage rapide
Exemple complet

Stakez du SOL en seulement 3 lignes de code :

// 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}`);

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.

Mise en œuvre complète du staking avec gestion des erreurs :

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

Référence des méthodes SDK

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 :

{
  serializedTx: string,        // Base58 encoded transaction
  stakeAccountPubkey: string   // New stake account address
}

Exemple :

const result = await helius.rpc.createStakeTransaction(
  payer.publicKey, 
  1.5  // 1.5 SOL
);

getStakeInstructions(owner, amount)

Renvoie uniquement les instructions pour le staking (utile pour la construction de transactions personnalisées).Retourne :

{
  instructions: TransactionInstruction[],
  stakeAccount: Keypair
}

Exemple :

const { instructions } = await helius.rpc.getStakeInstructions(
  payer.publicKey, 
  1.5
);

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

getHeliusStakeAccounts(wallet)

Récupère tous les comptes de staking délégués au validateur Helius pour un portefeuille.Exemple :

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

createUnstakeTransaction(owner, stakeAccount)

Crée une transaction pour désactiver (commencer le désengagement) un compte de staking.Exemple :

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());

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 :

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

createWithdrawTransaction(owner, stakeAccount, destination, amount)

Crée une transaction pour retirer du SOL d’un compte de staking désactivé.Exemple :

const tx = await helius.rpc.createWithdrawTransaction(
  payer.publicKey,
  stakeAccountPubkey,
  destinationPubkey,
  withdrawAmount  // in lamports
);

Workflow complet de staking

Créer et Déléguer

// 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}`);

Surveillez vos mises

// 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'}`);
});

Désactivation (commencer le désengagement)

// 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.');

Retirer du SOL

// 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`);
}

Modèles avancés

Intégration au navigateur
Opérations par lots
Transactions intelligentes

Pour les applications de navigateur utilisant des adaptateurs de portefeuille :

// 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()}`);

Stakez pour plusieurs portefeuilles efficacement :

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

Utilisez les transactions intelligentes pour une meilleure fiabilité et optimisation :

// 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}`);

Notes importantes

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.

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.

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.

Référence rapide

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

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

Documentation Helius SDK

Référence complète du SDK avec toutes les méthodes disponibles

Transactions intelligentes

Optimisez vos transactions avec des frais prioritaires et une logique de reprise

Rejoindre Discord

Obtenez de l’aide de notre communauté de développeurs

Tableau de bord du validateur

Surveillez les performances et les récompenses du validateur Helius

Commencez ici

Données en temps réel

Trading à faible latence

Données historiques et de portefeuille

Guides des méthodes RPC

Préparation à la production

Utilisation d'Orb

Autres modes d'emploi

Staking programmatique Solana avec Helius SDK

Aperçu rapide

Créer & Déléguer

Surveiller & Gérer

Retirer & Récupérer

Installation & Configuration

Notions de base sur le staking

Pour commencer

Référence des méthodes SDK

Workflow complet de staking

Modèles avancés

Notes importantes

Référence rapide

Prochaines étapes

Documentation Helius SDK

Transactions intelligentes

Rejoindre Discord

Tableau de bord du validateur

​Aperçu rapide

Créer & Déléguer

Surveiller & Gérer

Retirer & Récupérer

​Installation & Configuration

​Notions de base sur le staking

​Pour commencer

​Référence des méthodes SDK

​Workflow complet de staking

​Modèles avancés

​Notes importantes

​Référence rapide

​Prochaines étapes

Documentation Helius SDK

Transactions intelligentes

Rejoindre Discord

Tableau de bord du validateur

Aperçu rapide

Installation & Configuration

Notions de base sur le staking

Pour commencer

Référence des méthodes SDK

Workflow complet de staking

Modèles avancés

Notes importantes

Référence rapide

Prochaines étapes