Como criar uma wallet Solana: um guia técnico

Nos últimos anos, Solana surgiu como uma das redes blockchain mais ativas, com uma média de mais de 1,2 milhão de usuários ativos diários e 60M+ transações (não-voting) por dia. Essa atividade é impulsionada por DeFi, DePIN, instituições, empresas e muito mais, tudo acontecendo em alta velocidade e por frações de centavo por transação.

Se você quer construir em Solana e aproveitar esse ecossistema em crescimento, começar com uma wallet é um ótimo ponto de entrada. Wallets são a porta de entrada para interagir com qualquer chain: assinar transações, guardar ativos e alimentar apps.

Neste guia, vamos mostrar como criar uma wallet regular do Solana usando os endpoints de RPC confiáveis da Alchemy para conexões de rede sem atritos, e depois comparar wallets regulares e smart wallets. Vamos começar pela devnet, para você testar sem gastar SOL de verdade.

Wallets no Solana: o básico

No Solana, wallets não funcionam exatamente como você talvez esteja acostumado no Ethereum. Em vez de uma separação rígida entre contas controladas por usuário (EOAs) e smart contracts, Solana trata tudo como accounts, unidades de armazenamento de dados na blockchain. Uma "wallet" aqui costuma ser apenas um keypair (chave pública e privada) que permite controlar uma ou mais dessas accounts. Accounts podem guardar tokens SOL, outros ativos, ou até código executável de programs (a versão do Solana para smart contracts).

Essa abordagem uniforme abre espaço para recursos interessantes como program derived addresses (PDAs), em que programs podem gerar endereços e até assinar transações em nome de usuários sem precisar das chaves privadas deles.

É um modelo mais flexível do que o do Ethereum, onde EOAs servem apenas para assinar e os contracts cuidam da lógica separadamente. Para saber mais sobre o modelo de accounts do Solana, veja a documentação oficial do Solana sobre accounts e wallets.

Wallets do Solana geralmente se dividem em duas categorias:

• Wallets regulares (baseadas em keypair): são keypairs criptográficos simples para assinar transações e gerenciar accounts. Ótimas para scripts ou testes, mas você precisa cuidar das chaves e das taxas manualmente.
• Smart wallets (com account abstraction): elevam a experiência escondendo detalhes como gerenciamento de chaves. Smart wallets suportam coisas como autenticação social (por exemplo, login com email ou passkeys em vez de seed phrases), patrocínio de gas/rent (em que outra parte paga as taxas de transação), transações em lote (várias ações de uma vez) e até comportamentos automatizados via lógica programável. O design do Solana torna esses recursos especialmente poderosos para apps, indo além do foco do ERC-4337 do Ethereum em ajustes de UX. Aprofunde-se em account abstraction no Solana com o Solana Cookbook sobre wallet management e o deep dive de ERC-4337 no Solana.

Neste tutorial, vamos construir uma wallet regular usando os endpoints de RPC da Alchemy, que dão acesso confiável à rede Solana sem que você precise rodar seu próprio node. Para recursos de smart wallet como login social, combine um wallet provider com a infraestrutura da Alchemy.

Pré-requisitos: configurando seu ambiente de Devnet

Antes de partir para o código, vamos garantir que você está pronto. Este tutorial assume que você tem conhecimento básico de JavaScript, mas vamos explicar os conceitos ao longo do caminho para todo mundo acompanhar. Aqui está o que você vai precisar:

• Node.js (v16 ou superior) e npm/yarn: seu runtime para rodar código JS fora do navegador. Você pode baixar em nodejs.org se ainda não tiver.

• Um editor de código como VS Code ou Cursor: um lugar para escrever e debugar seu código. VS Code é gratuito e tem ótimas extensões para desenvolvimento blockchain. Você pode se preparar aqui. Cursor é como uma versão mais avançada e com IA do VS Code. Você pode conferir aqui.

• Conhecimento básico de JavaScript: os exemplos usam Node.js e Solana web3.js.

• Uma conta na Alchemy: cadastre-se de graça em dashboard.alchemy.com. Crie um novo app, selecione Solana (devnet para testes, mainnet para produção), e pegue sua API key. Enquanto estiver lá, ative uma chain EVM como Sepolia se quiser suporte híbrido – útil para apps cross-chain.

• Para wallets regulares: instale a biblioteca Solana web3.js, que cuida de geração de chaves, conexões e transações. Essa biblioteca é a referência para interagir com programs do Solana.

  npm install @solana/web3.js

Dica: construa tudo primeiro na devnet. É o ambiente de testes principal, que reproduz o deploy na mainnet perfeitamente e permite testar seus contracts, rodar seus fluxos e garantir que tudo funciona. Depois que estiver confiante, tiver feito deploy na testnet e testado tudo a fundo, fazer deploy na mainnet é tão simples quanto trocar a RPC URL. Sem mudanças de código: só apertar o botão.

Entendendo a estrutura de wallets do Solana

Antes de gerar uma wallet, vamos dar um passo atrás e contextualizar rapidamente como wallets funcionam no Solana. Isso vai ajudar a entender por que os próximos passos fazem sentido, especialmente se você vem do Ethereum.

• Accounts vs. wallets: no Solana, uma wallet é essencialmente um keypair que possui accounts. Accounts são como "baldes" de dados: podem guardar seu saldo em SOL, tokens, ou código de program. Diferente do Ethereum, onde EOAs (endereços de usuário) são distintos de endereços de contract, Solana borra essa linha: tudo é uma account. Isso significa que você pode criar accounts sob demanda, financiá-las separadamente, e até ter programs controlando-as via PDAs. Não há criação automática de account na geração da chave; você financia para inicializar. Para se aprofundar, veja os conceitos essenciais do Solana.
• Rent em vez de taxas de gas dinâmicas: Solana não usa gas no estilo Ethereum para cada unidade de computação: transações têm taxas fixas (muito baixas, cerca de $0,00025 em média em 2025), mas accounts pagam "rent" para manter seus dados armazenados na chain se o saldo cair abaixo de um limite (cerca de 0,00089 SOL por KB). É como um depósito de armazenamento: pague adiantado ou mantenha SOL suficiente para ficar isento. Isso mantém a rede enxuta ao remover accounts inativas. Transações ainda custam taxas, mas rent é o diferencial único para persistência. Você pode comparar com o gas do Ethereum, que cobra por operação e pode disparar durante congestionamento. O modelo do Solana prioriza velocidade. Leia mais na documentação de rent do Solana.
• PDAs e programabilidade: programs podem derivar "program derived addresses" que parecem endereços comuns, mas são controlados por código, não por chaves, o que permite recursos de smart wallet como assinatura automatizada. Isso está mais embutido na arquitetura central do Solana do que as contract wallets do Ethereum.

Entender esses conceitos ajuda a ver por que wallets no Solana parecem mais "programáveis" de fábrica. Tudo volta a esse conceito de accounts flexíveis.

Como criar uma wallet regular no Solana: passo a passo

Wallets regulares são seu setup de nível básico: um keypair simples para assinar transações. São perfeitas para scripts de backend, testes, ou quando você quer controle total sem abstrações. Neste tutorial, vamos usar @solana/web3.js para gerar um keypair.

Em seguida, vamos usar a RPC da Alchemy para conectar à rede; sem uma conexão RPC, sua wallet não consegue consultar saldos ou enviar transações.

Passo 1: gerar um keypair

Gerar uma wallet no Solana significa criar um novo par de chaves criptográficas, basicamente um par de chaves matematicamente ligadas que funcionam juntas. A chave pública se torna seu endereço de wallet no Solana, que você pode compartilhar livremente com quem precisar te enviar fundos ou interagir com sua account. A chave privada (também chamada de secret key) é o que comprova que você possui aquele endereço e permite assinar transações.

Aqui vai uma distinção importante em relação ao Ethereum: no Ethereum, quando você gera uma Externally Owned Account (EOA), ela já existe "pronta" na blockchain. No Solana, gerar um keypair apenas cria as chaves criptográficas; a account de fato na blockchain não existe até que alguém financie esse endereço. Isso faz parte do modelo de accounts do Solana, em que accounts precisam de saldo de isenção de rent para persistir on chain.

Crie um novo arquivo JS (digamos, regular-wallet.js) e rode este trecho:

Rode esse script com node.js e pronto: você tem uma wallet.

Aqui está o que você deveria ter recebido de volta:

• Public Key (Endereço da Wallet): uma string codificada em base58 que se parece com 7xj9WkvP6Az8vG5nXJh4Fq3qY8kPqT9wXVZN2xMqGnD4. É isso que você vai compartilhar com outras pessoas quando quiser receber fundos, e é o que você vai usar ao se conectar a apps ou checar seu saldo. Pense nisso como o número da sua conta bancária, é seguro compartilhar publicamente.
• Secret Key: retornada como um Uint8Array (um array de 64 bytes). Essa é sua chave privada e é a prova criptográfica de que você controla essa wallet. Qualquer pessoa com acesso a essa secret key pode assinar transações e movimentar fundos da sua wallet. Nunca, jamais compartilhe isso ou faça commit dela no controle de versão.

Práticas de segurança críticas para a secret key:

• Nunca faça log dela em produção: o console.log no nosso exemplo é aceitável para testes locais, mas remova antes de fazer deploy de qualquer aplicação real.
• Use variáveis de ambiente: guarde-a em um arquivo .env que esteja adicionado ao seu .gitignore. Acesse com process.env.PRIVATE\_KEY no seu código.
• Considere hardware wallets: para aplicações em produção lidando com valores significativos, integre hardware wallets como Ledger ou Trezor que mantêm as chaves privadas isoladas em hardware seguro.
• Criptografe caso armazene: se você precisar guardar a secret key em um banco de dados ou arquivo, criptografe-a primeiro usando bibliotecas de criptografia robustas.

Para boas práticas de segurança, veja o guia de segurança do Solana.

Passo 2: conectar à rede via RPC da Alchemy

Agora, conecte sua wallet à devnet do Solana usando um endpoint de RPC. Esse objeto de "conexão" permite que seu código converse com a blockchain, busque saldos, envie transações, etc. A RPC da Alchemy funciona como um proxy turbinado para nodes do Solana, cuidando do balanceamento de carga para que seu app permaneça responsivo.

Adicione isso ao seu script (substitua <YOUR_API_KEY> pela sua chave do dashboard da Alchemy):

Essa conexão permite verificar se sua wallet está financiada e interagir com apps. Rode o script; se não estiver financiada, a resposta vai mostrar 0 SOL. Para todos os métodos de RPC, veja a documentação de RPC do Solana ou nosso guia de RPC da Alchemy para Solana.

Passo 3: financiar e interagir com sua wallet

Com a conexão ativa, vamos interagir on chain. É aqui que a diversão começa: financiamento via airdrop (apenas devnet), assinatura de transações, etc. Esses fundamentos permitem transferir SOL, chamar programs, ou construir ferramentas simples.

Solicitar um airdrop (financiamento na devnet)

A devnet oferece SOL gratuito para testes, permitindo financiar sua account se ela estiver vazia, mas fique atento ao limite de ~24 SOL/dia por endereço IP.

Você vai precisar financiar sua account para isenções de rent em taxas. Esse método também só funciona na devnet. Em produção, onde as taxas são pagas em SOL real (e não SOL de teste), você vai precisar comprar/financiar sua account via uma exchange como a Coinbase. Veja o guia de Devnet SOL do Solana.

Aqui está o que está acontecendo:

• Solicitar o airdrop: connection.requestAirdrop\(\) pede SOL de teste à devnet. Ele usa a chave pública da sua wallet e o valor em lamports (1e9 = 1 SOL), e retorna uma assinatura de transação, um identificador único para essa transação.
• Confirmar a transação: await connection.confirmTransaction\(\) espera a rede processar seu airdrop. Isso é crucial: sem esperar pela confirmação, seu saldo pode continuar mostrando 0 SOL mesmo com o airdrop já solicitado. O Solana processa transações de forma assíncrona, então é preciso aguardar.
• Sucesso: uma vez confirmado, rode checkBalance\(\) novamente e você deve ver 1 SOL na sua wallet.

Assinar e enviar uma transação

Vamos transferir 0,1 SOL para outro endereço. Este exemplo demonstra a assinatura de transações, em que sua chave privada autoriza criptograficamente a transação, provando que você é o dono da wallet remetente. Vamos montar uma transação, assiná-la com seu keypair, e transmiti-la para a rede via RPC. As taxas de transação (cerca de 0,000005 SOL) são deduzidas automaticamente do seu saldo. Para operações mais complexas, como transações com múltiplas instruções ou chamadas a programs, explore a documentação de fundamentos de transações do Solana.

Rode este código para enviar SOL:

Aqui está o que está acontecendo:

• Criar o destinatário: new PublicKey\(\) converte uma string de endereço codificada em base58 em um objeto PublicKey que o Solana consegue processar. Substitua 'recipient\_address\_here' por um endereço Solana real (você pode até usar a chave pública da sua própria wallet para testar o envio para si mesmo).
• Montar a transação: new Transaction\(\).add\(\) cria uma transação e adiciona uma instrução de transferência. A chamada SystemProgram.transfer\(\) especifica o remetente (fromPubkey), o destinatário (toPubkey), e o valor em lamports (1e8 = 0,1 SOL).
• Enviar e confirmar: sendAndConfirmTransaction\(\) é uma função auxiliar que cuida de três etapas de uma vez: busca o blockhash mais recente (exigido em todas as transações do Solana), assina a transação com o keypair da sua wallet, envia para a rede, e espera pela confirmação. O array \[wallet\] contém todos os signatários, nesse caso, só a sua wallet.
• Assinatura da transação: a assinatura retornada é sua prova de execução, um identificador único para essa transação específica na blockchain.
• Dica de segurança: nunca faça hardcode de secret keys. Em vez disso, use process.env.PRIVATE\_KEY. Para produção, integre hardware wallets para reduzir outros pontos de ataque. Para mais sobre gerenciamento seguro de chaves, veja nossas boas práticas de gerenciamento de chaves e segurança.

E se tudo correu bem, você deve ter recebido de volta uma assinatura de transação bem-sucedida! Essa assinatura é sua prova de que a transação foi processada na blockchain do Solana. Você pode procurar por ela no Solana Explorer para ver os detalhes completos: remetente, destinatário, taxa paga, e confirmação de bloco.

Essa é a essência de interagir com uma wallet do Solana simples na devnet: gerar um keypair, conectar via RPC, financiar, e assinar transações. Esses blocos fundamentais: geração de keypair, conexão de rede, verificação de saldo, e assinatura de transações são a base para qualquer trabalho de desenvolvimento no Solana.

Essas wallets regulares baseadas em keypair com as quais acabamos de interagir são perfeitas para scripts de backend que precisam de controle programático, testes e desenvolvimento, para quem prefere gerenciar as próprias chaves diretamente, e casos de uso simples como transferências básicas e interações com programs. No entanto, como você pode ver, elas têm suas próprias contrapartidas: usuários precisam gerenciar as próprias chaves, pagar as próprias taxas, e lidar com a complexidade técnica das interações com a blockchain. Para apps voltados ao consumidor, onde UX importa, esse atrito pode ser um obstáculo decisivo.

É aí que entram as smart wallets. Elas abstraem a complexidade enquanto oferecem recursos poderosos como login social, transações sem gas, e session keys.

Wallets regulares vs. smart wallets: uma comparação rápida

Para ajudar você a decidir o que precisa para o seu caso de uso, aqui está uma tabela detalhando as principais diferenças entre os tipos de wallet no Solana. Isso mostra quando usar cada uma nos seus projetos.

Boas práticas: pontos a considerar durante a construção

Ao construir sua wallet no Solana, aqui estão algumas boas práticas e dicas para garantir que ela seja segura, escalável e amigável ao usuário.

• Segurança em primeiro lugar: para wallets regulares, sempre use hardware wallets (como Ledger ou Trezor) para mainnet, mantendo as chaves offline. Com smart wallets, use as passkeys ou autenticação multifator do seu wallet provider para reduzir riscos de phishing evitando seed phrases. Nunca exponha secrets no código; use armazenamento criptografado. Audite seu setup com ferramentas como o guia de segurança do Solana.
• Teste a fundo: sempre comece na devnet ou testnet para iterar sem custos. Use o dashboard da Alchemy para monitorar uso de RPC, falhas de transação, e métricas de performance. É como um debugger embutido para suas chamadas de blockchain. Simule casos extremos como congestionamento de rede para garantir que os retries funcionam.
• Tratamento de erros e confiabilidade: envolva as chamadas de RPC em blocos try-catch e adicione retries com backoff exponencial (por exemplo, via bibliotecas como p-retry). A velocidade do Solana pode gerar race conditions, então confirme transações com o commitment 'finalized' para máxima segurança. Isso mantém seu app robusto, especialmente para apps de alto volume.
• Considerações de escalabilidade: a infraestrutura da Alchemy escala automaticamente para cargas altas, então você não vai enfrentar gargalos na RPC. Para smart wallets, agrupe operações quando possível para minimizar transações. Monitore isenções de rent para evitar custos inesperados. Ferramentas como o Solscan explorer ajudam a acompanhar isso.
• Recursos para se aprofundar: fique atualizado com a documentação de Solana da Alchemy para mudanças no SDK, e explore os adaptadores oficiais de wallet React do Solana para integrações de UI.

Encerrando: hora de construir no Solana

Pronto – agora você sabe como criar uma wallet regular no Solana com a ajuda da Alchemy, e como as smart wallets se comparam. Seja fazendo scripts de transferências simples ou construindo um dApp de peso com logins sem gas, o ecossistema do Solana está pronto para inovação. Agora é a hora de mergulhar e começar a experimentar. Para saber mais, confira nossos recursos completos para desenvolvedores Solana e a documentação do Solana. Boa construção – se tiver dúvidas, visite a central de suporte da Alchemy. Vamos fazer um pouco de magia on chain!

Perguntas frequentes

O que é uma wallet do Solana?

Uma wallet do Solana é um keypair (chave pública e privada) que permite controlar accounts na blockchain do Solana, as quais podem guardar tokens SOL, outros ativos, ou código executável. Diferente do modelo de EOA do Ethereum, o Solana trata tudo como accounts, com uma estrutura mais flexível e programável.

Preciso pagar para criar uma wallet do Solana?

Não, gerar um keypair é gratuito, mas accounts no Solana exigem rent (cerca de 0,00089 SOL por KB) para persistir on-chain, e as taxas de transação têm média de $0,00025. Na devnet você pode obter SOL de teste gratuito via airdrop, mas na mainnet é preciso comprar SOL.

Qual a diferença entre wallets regulares e smart wallets no Solana?

Wallets regulares são keypairs básicos em que você gerencia manualmente as chaves e paga as taxas, ideais para scripts e testes. Smart wallets usam account abstraction para oferecer login social, patrocínio de gas, transações em lote, e lógica programável, perfeitas para apps voltados ao usuário.

Posso usar login social em vez de seed phrases?

Sim, muitos wallet providers de smart wallet permitem que usuários se autentiquem via email, Google, ou passkeys em vez de gerenciar seed phrases. Isso elimina o atrito do gerenciamento tradicional de chaves para os usuários.

Como financio minha wallet do Solana na devnet?

Use connection.requestAirdrop() para obter SOL de teste gratuito na devnet (limitado a ~24 SOL/dia por IP). Para mainnet, você vai precisar comprar SOL através de uma exchange como a Coinbase.

O que é rent no Solana?

Rent é um sistema de depósito de armazenamento em que accounts precisam manter um saldo mínimo de SOL (cerca de 0,00089 SOL por KB) para permanecer ativas on-chain. É diferente das taxas de gas do Ethereum e ajuda a manter a rede eficiente removendo accounts inativas.

Smart wallets podem patrocinar taxas de transação para usuários?

Sim, alguns wallet providers de smart wallet suportam patrocínio de gas e rent. Isso permite que seu app pague as taxas dos usuários, viabilizando experiências sem gas que aumentam conversões e simplificam o onboarding.

Preciso rodar meu próprio node Solana?

Não, nossos endpoints de RPC fornecem acesso confiável à rede Solana sem que você precise rodar seu próprio node. O serviço cuida do balanceamento de carga, da escalabilidade, e oferece conexões HTTP e WebSocket para atualizações em tempo real.