Programmgesteuertes Solana-Staking mit dem Helius SDK

Validator ohne Provision: Stake beim Helius Validator und behalte dank 0 % Provision 100 % deiner Staking-Rewards.

Kurzübersicht

Das Helius SDK bietet einfache Methoden, mit denen du den gesamten SOL-Staking-Lebenszyklus programmgesteuert verwalten kannst. Ideal für Staking-Oberflächen, DeFi-Protokolle oder automatisierte Staking-Strategien.

Create & Delegate

Erstelle neue Stake Accounts und delegiere sie in einer einzigen Transaktion an Validatoren

Monitor & Manage

Verfolge Rewards, prüfe den Status und verwalte vorhandene Stake Accounts

Withdraw & Redeem

Deaktiviere Stakes und zahle SOL nach Ablauf der Abkühlphasen aus

Installation und Einrichtung

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

Grundlagen des Stakings

How Solana Staking Works

Stake Account: Ein spezielles Konto, das SOL sperrt und an einen Validator delegiert. Jeder Stake Account verweist auf genau einen Validator.Rewards: Validatoren erhalten Rewards für die Absicherung des Netzwerks. Diese Rewards werden an alle Stake Accounts verteilt, die an diesen Validator delegiert sind.Lebenszyklus: Erstellen → Delegieren → Rewards verdienen → Deaktivieren → Auszahlen

Why Choose Helius Validator

0 % Provision: Behalte 100 % deiner Staking-Rewards
Hohe Leistung: Zuverlässige Blockproduktion und minimale Ausfallzeiten
Einfache Integration: Für das Helius SDK optimiert, mit integrierten Hilfsfunktionen

Timing & Epochs

Aktivierung: Stakes werden zu Beginn der nächsten Epoche aktiv (~2 Tage)
Deaktivierung: Wird am Ende der aktuellen Epoche wirksam
Abkühlphase: Deaktivierte Stakes können direkt nach dem Ende der Epoche ausgezahlt werden

Erste Schritte

Quick Start
Complete Example

Stake SOL mit nur 3 Codezeilen:

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

Das SDK berechnet die Rent automatisch und erstellt den Stake Account. Der Parameter 1.5 gibt den Betrag in SOL an, den du staken möchtest.

Vollständige Staking-Implementierung mit Fehlerbehandlung:

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

Referenz der SDK-Methoden

createStakeTransaction(owner, amount)

Erstellt eine vollständige Staking-Transaktion, die signiert und gesendet werden kann.Parameter:

owner (PublicKey): Die Wallet, der der Stake Account gehören wird
amount (number): Zu stakender SOL-Betrag

Rückgabewert:

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

Beispiel:

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

getStakeInstructions(owner, amount)

Gibt nur die Staking-Anweisungen zurück. Das ist nützlich, wenn du eigene Transaktionen erstellst.Rückgabewert:

{
  instructions: TransactionInstruction[],
  stakeAccount: Keypair
}

Beispiel:

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

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

getHeliusStakeAccounts(wallet)

Ruft alle Stake Accounts einer Wallet ab, die an den Helius Validator delegiert sind.Beispiel:

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)

Erstellt eine Transaktion, um einen Stake Account zu deaktivieren und das Unstaking zu starten.Beispiel:

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?)

Prüft, wie viel SOL aus einem deaktivierten Stake Account ausgezahlt werden kann.Parameter:

includeRent (boolean): Ob der von der Rent befreite Betrag einbezogen werden soll

Beispiel:

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)

Erstellt eine Transaktion, um SOL aus einem deaktivierten Stake Account auszuzahlen.Beispiel:

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

Vollständiger Staking-Ablauf

Create and Delegate

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

Monitor Your Stakes

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

Deactivate (Start Unstaking)

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

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

Fortgeschrittene Muster

Browser Integration
Batch Operations
Smart Transactions

Für Browseranwendungen mit Wallet-Adaptern:

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

Stake effizient für mehrere Wallets:

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

Nutze Smart Transactions für höhere Zuverlässigkeit und bessere Optimierung:

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

Wichtige Hinweise

Epochen-Timing: Solana-Epochen dauern etwa 2 Tage. Stakes werden zu Beginn der nächsten Epoche aktiviert. Die Deaktivierung wird am Ende der aktuellen Epoche wirksam.

Rent berücksichtigen: Stake Accounts benötigen von der Rent befreite Reserven (~0,00228 SOL). Wenn du das gesamte Guthaben auszahlst, wird das Konto geschlossen.

Hardware-Wallets: Nutzern werden zwei Signaturaufforderungen angezeigt: eine für den Stake Account, die vorab signiert wurde, und eine für den Gebührenzahler. Gestalte deine UX entsprechend.

Kurzreferenz

Brauchst du eine schnelle Übersicht? Hier sind die wichtigsten Methoden:

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

Nächste Schritte

Helius SDK Documentation

Vollständige SDK-Referenz mit allen verfügbaren Methoden

Smart Transactions

Optimiere deine Transaktionen mit Prioritätsgebühren und Wiederholungslogik

Join Discord

Erhalte Hilfe von unserer Entwickler-Community

Validator Dashboard

Überwache die Leistung und Rewards des Helius Validators

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Programmgesteuertes Solana-Staking mit dem Helius SDK

Kurzübersicht

Create & Delegate

Monitor & Manage

Withdraw & Redeem

Installation und Einrichtung

Grundlagen des Stakings

Erste Schritte

Referenz der SDK-Methoden

Vollständiger Staking-Ablauf

Fortgeschrittene Muster

Wichtige Hinweise

Kurzreferenz

Nächste Schritte

Helius SDK Documentation

Smart Transactions

Join Discord

Validator Dashboard

​Kurzübersicht

Create & Delegate

Monitor & Manage

Withdraw & Redeem

​Installation und Einrichtung

​Grundlagen des Stakings

​Erste Schritte

​Referenz der SDK-Methoden

​Vollständiger Staking-Ablauf

​Fortgeschrittene Muster

​Wichtige Hinweise

​Kurzreferenz

​Nächste Schritte

Helius SDK Documentation

Smart Transactions

Join Discord

Validator Dashboard

Kurzübersicht

Installation und Einrichtung

Grundlagen des Stakings

Erste Schritte

Referenz der SDK-Methoden

Vollständiger Staking-Ablauf

Fortgeschrittene Muster

Wichtige Hinweise

Kurzreferenz

Nächste Schritte