Staking programático de Solana con Helius SDK

Validador sin comisión: Haz staking con el validador de Helius y conserva el 100 % de tus recompensas de staking gracias a nuestra tasa de comisión del 0 %.

Descripción general rápida

Helius SDK proporciona métodos sencillos para gestionar mediante programación todo el ciclo de vida del staking de SOL. Es ideal para crear interfaces de staking, protocolos DeFi o estrategias automatizadas de staking.

Create & Delegate

Configura nuevas cuentas de stake y delégalas a validadores en una sola transacción

Monitor & Manage

Haz seguimiento de las recompensas, consulta el estado y administra las cuentas de stake existentes

Withdraw & Redeem

Desactiva stakes y retira SOL después de los períodos de enfriamiento

Instalación y configuración

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

Conceptos básicos del staking

How Solana Staking Works

Cuenta de stake: Una cuenta especial que bloquea SOL y lo delega a un validador. Cada cuenta de stake apunta exactamente a un validador.Recompensas: Los validadores obtienen recompensas por proteger la red. Estas recompensas se distribuyen entre todas las cuentas de stake delegadas a ese validador.Ciclo de vida: Crear → Delegar → Obtener recompensas → Desactivar → Retirar

Why Choose Helius Validator

0 % de comisión: Conserva el 100 % de tus recompensas de staking
Alto rendimiento: Producción de bloques confiable y tiempo de inactividad mínimo
Integración sencilla: Optimizado para Helius SDK con funciones auxiliares integradas

Timing & Epochs

Activación: Los stakes se activan al inicio de la siguiente época (~2 días)
Desactivación: Entra en vigor al final de la época actual
Enfriamiento: Los stakes desactivados pueden retirarse inmediatamente después de que termine la época

Primeros pasos

Quick Start
Complete Example

Haz staking de SOL con solo 3 líneas de código:

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

El SDK gestiona automáticamente el cálculo de la renta y la creación de la cuenta de stake. El parámetro 1.5 es la cantidad de SOL que quieres poner en staking.

Implementación completa de staking con gestión de errores:

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

Referencia de métodos del SDK

createStakeTransaction(owner, amount)

Crea una transacción de staking completa que se puede firmar y enviar.Parámetros:

owner (PublicKey): La billetera que será propietaria de la cuenta de stake
amount (number): Cantidad de SOL que se pondrá en staking

Devuelve:

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

Ejemplo:

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

getStakeInstructions(owner, amount)

Devuelve solo las instrucciones para hacer staking (útil para crear transacciones personalizadas).Devuelve:

{
  instructions: TransactionInstruction[],
  stakeAccount: Keypair
}

Ejemplo:

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

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

getHeliusStakeAccounts(wallet)

Obtiene todas las cuentas de stake de una billetera delegadas al validador de Helius.Ejemplo:

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)

Crea una transacción para desactivar una cuenta de stake (iniciar la salida del staking).Ejemplo:

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

Consulta cuánto SOL se puede retirar de una cuenta de stake desactivada.Parámetros:

includeRent (boolean): Indica si se debe incluir la cantidad exenta de renta

Ejemplo:

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)

Crea una transacción para retirar SOL de una cuenta de stake desactivada.Ejemplo:

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

Flujo de trabajo completo de staking

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

Patrones avanzados

Browser Integration
Batch Operations
Smart Transactions

Para aplicaciones de navegador que usan adaptadores de billetera:

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

Haz staking de forma eficiente para varias billeteras:

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

Usa Smart Transactions para mejorar la confiabilidad y la optimización:

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

Notas importantes

Duración de las épocas: Las épocas de Solana duran ~2 días. Los stakes se activan al inicio de la siguiente época y la desactivación entra en vigor al final de la época actual.

Consideraciones sobre la renta: Las cuentas de stake necesitan reservas exentas de renta (~0.00228 SOL). Retirar el saldo completo cierra la cuenta.

Billeteras de hardware: Los usuarios verán dos solicitudes de firma: una para la cuenta de stake (firmada previamente) y otra para quien paga la comisión. Diseña tu experiencia de usuario en consecuencia.

Referencia rápida

¿Necesitas un recordatorio rápido? Estos son los métodos esenciales:

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

Próximos pasos

Helius SDK Documentation

Referencia completa del SDK con todos los métodos disponibles

Smart Transactions

Optimiza tus transacciones con comisiones de prioridad y lógica de reintentos

Join Discord

Obtén ayuda de nuestra comunidad de desarrolladores

Validator Dashboard

Supervisa el rendimiento y las recompensas del validador de Helius

Comienza aquí

Datos en tiempo real

Trading de baja latencia

Datos históricos y de billeteras

Guías de métodos RPC

Preparación para producción

Uso de Orb

Otras guías prácticas

Staking programático de Solana con Helius SDK

Descripción general rápida

Create & Delegate

Monitor & Manage

Withdraw & Redeem

Instalación y configuración

Conceptos básicos del staking

Primeros pasos

Referencia de métodos del SDK

Flujo de trabajo completo de staking

Patrones avanzados

Notas importantes

Referencia rápida

Próximos pasos

Helius SDK Documentation

Smart Transactions

Join Discord

Validator Dashboard

​Descripción general rápida

Create & Delegate

Monitor & Manage

Withdraw & Redeem

​Instalación y configuración

​Conceptos básicos del staking

​Primeros pasos

​Referencia de métodos del SDK

​Flujo de trabajo completo de staking

​Patrones avanzados

​Notas importantes

​Referencia rápida

​Próximos pasos

Helius SDK Documentation

Smart Transactions

Join Discord

Validator Dashboard

Descripción general rápida

Instalación y configuración

Conceptos básicos del staking

Primeros pasos

Referencia de métodos del SDK

Flujo de trabajo completo de staking

Patrones avanzados

Notas importantes

Referencia rápida

Próximos pasos