Staking Programático Solana com Helius SDK

Validador de Comissão Zero: Firme com o validador Helius e mantenha 100% de suas recompensas de staking com nossa taxa de comissão de 0%.

Visão Geral Rápida

O Helius SDK fornece métodos simples para lidar com todo o ciclo de vida do staking SOL programaticamente. Perfeito para construir interfaces de staking, protocolos DeFi ou estratégias automatizadas de staking.

Criar & Delegar

Configure novas contas de staking e delegue para validadores em uma transação

Monitorar & Gerenciar

Acompanhe recompensas, verifique o status e gerencie contas de staking existentes

Sacar & Resgatar

Desative stakes e saque SOL após períodos de espera

Instalação & Configuração

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

Noções Básicas de Staking

Como Funciona o Staking Solana

Conta de Stake: Uma conta especial que bloqueia SOL e o delega a um validador. Cada conta de stake aponta para exatamente um validador.Recompensas: Validadores ganham recompensas por proteger a rede. Essas recompensas são distribuídas a todas as contas de stake delegadas a esse validador.Ciclo de Vida: Criar → Delegar → Ganhar Recompensas → Desativar → Sacar

Por Que Escolher o Validador Helius

0% de Comissão: Mantenha 100% de suas recompensas de staking
Alto Desempenho: Produção de blocos confiável e tempo de inatividade mínimo
Integração Fácil: Otimizado para o Helius SDK com auxiliares integrados

Tempo & Épocas

Ativação: Stakes se tornam ativos no início da próxima época (~2 dias)
Desativação: Entra em vigor no final da época atual
Espera: Stakes desativados podem ser sacados imediatamente após o final da época

Primeiros Passos

Início Rápido
Exemplo Completo

Stake SOL em apenas 3 linhas 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}`);

O SDK lida automaticamente com o cálculo de aluguel e criação de contas de stake. O parâmetro 1.5 é a quantia em SOL que você deseja apostar.

Implementação completa de staking com tratamento de erros:

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

Referência de Métodos do SDK

createStakeTransaction(owner, amount)

Cria uma transação de staking completa que pode ser assinada e enviada.Parâmetros:

owner (PublicKey): A carteira que será proprietária da conta de stake
amount (number): Quantia de SOL a ser apostada

Retorna:

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

Exemplo:

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

getStakeInstructions(owner, amount)

Retorna apenas as instruções para staking (útil para construção de transações personalizadas).Retorna:

{
  instructions: TransactionInstruction[],
  stakeAccount: Keypair
}

Exemplo:

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

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

getHeliusStakeAccounts(wallet)

Recupera todas as contas de stake delegadas ao validador Helius para uma carteira.Exemplo:

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)

Cria uma transação para desativar (iniciar desinvestimento) uma conta de stake.Exemplo:

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

Verifique quanto SOL pode ser sacado de uma conta de stake desativada.Parâmetros:

includeRent (boolean): Se deve incluir o valor isento de aluguel

Exemplo:

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)

Cria uma transação para sacar SOL de uma conta de stake desativada.Exemplo:

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

Fluxo Completo de Staking

Criar e Delegar

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

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

Desativar (Iniciar Desinvestimento)

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

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

Padrões Avançados

Integração com Navegador
Operações em Lote
Transações Inteligentes

Para aplicativos de navegador usando adaptadores de carteira:

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

Aposte para várias carteiras de forma eficiente:

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

Use Transações Inteligentes para melhor confiabilidade e otimização:

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

Tempo de Época: As épocas de Solana duram ~2 dias. Stakes são ativados no início da próxima época, e a desativação entra em vigor no final da época atual.

Considerações de Aluguel: Contas de stake precisam de reservas isentas de aluguel (~0.00228 SOL). Sacar o saldo total fecha a conta.

Carteiras de Hardware: Os usuários verão dois prompts de assinatura - um para a conta de stake (pré-assinada) e outro para o pagador da taxa. Projetem sua UX de acordo.

Referência Rápida

Precisa de um lembrete rápido? Aqui estão os métodos essenciais:

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

Documentação do Helius SDK

Referência completa do SDK com todos os métodos disponíveis

Transações Inteligentes

Otimize suas transações com taxas prioritárias e lógica de reexecução

Junte-se ao Discord

Obtenha ajuda da nossa comunidade de desenvolvedores

Painel do Validador

Monitore o desempenho e as recompensas do validador Helius

Comece aqui

Dados em tempo real

Negociação de baixa latência

Dados históricos e de carteiras

Guias de métodos RPC

Preparação para produção

Como usar o Orb

Outros tutoriais

Staking Programático Solana com Helius SDK

Visão Geral Rápida

Criar & Delegar

Monitorar & Gerenciar

Sacar & Resgatar

Instalação & Configuração

Noções Básicas de Staking

Primeiros Passos

Referência de Métodos do SDK

Fluxo Completo de Staking

Padrões Avançados

Notas Importantes

Referência Rápida

Próximos Passos

Documentação do Helius SDK

Transações Inteligentes

Junte-se ao Discord

Painel do Validador

​Visão Geral Rápida

Criar & Delegar

Monitorar & Gerenciar

Sacar & Resgatar

​Instalação & Configuração

​Noções Básicas de Staking

​Primeiros Passos

​Referência de Métodos do SDK

​Fluxo Completo de Staking

​Padrões Avançados

​Notas Importantes

​Referência Rápida

​Próximos Passos

Documentação do Helius SDK

Transações Inteligentes

Junte-se ao Discord

Painel do Validador

Visão Geral Rápida

Instalação & Configuração

Noções Básicas de Staking

Primeiros Passos

Referência de Métodos do SDK

Fluxo Completo de Staking

Padrões Avançados

Notas Importantes

Referência Rápida

Próximos Passos