14.11.2024

Aula 025: Construindo e Implantando Programas Solana

Nesta aula, cobriremos os fundamentos de como construir e implantar contratos inteligentes (chamados de programas) na blockchain Solana usando Rust. A Solana é conhecida por sua alta capacidade de processamento e baixas taxas de transação, tornando-a uma plataforma atraente para aplicações descentralizadas.

Pré-requisitos

Antes de começarmos, certifique-se de que você tenha o seguinte instalado:

• Rust: Você pode instalá-lo usando rustup.
• Solana CLI: Siga o guia oficial para instalar as Ferramentas de Linha de Comando da Solana.
• Cargo: Isso já está incluído com o Rust, então, se você tem o Rust instalado, está tudo pronto.

Criando um Novo Programa Solana

1. Configure Seu Ambiente

   Primeiro, crie um novo diretório para seu programa Solana:

   mkdir meu_programa_solana
   cd meu_programa_solana

2. Crie um Novo Projeto Cargo

   Use o Cargo para criar um novo projeto Rust:

   cargo new --lib meu_programa
   cd meu_programa

3. Atualize o Cargo.toml

   Abra o Cargo.toml e adicione as dependências necessárias para o desenvolvimento na Solana:

   [package]
   name = "meu_programa"
   version = "0.1.0"
   edition = "2018"
   
   [dependencies]
   solana-program = "1.9.0"  # Use a versão mais recente, se disponível

4. Implemente Seu Programa

   Abra o arquivo src/lib.rs e implemente um programa Solana simples que receberá um valor e o armazenará em uma conta. Aqui está um exemplo:

   use solana_program::{
      account_info::AccountInfo,
      entrypoint,
      entrypoint::ProgramResult,
      msg,
      pubkey::Pubkey,
      system_instruction,
      sysvar::Sysvar,
   };
   
   entrypoint!(process_instruction);
   
   fn process_instruction(
      _program_id: &Pubkey,
      accounts: &[AccountInfo],
      _instruction_data: &[u8],
   ) -> ProgramResult {
      msg!("Olá do meu programa Solana!");
   
      // Adicione lógica aqui para trabalhar com dados da conta.
      // Por exemplo, você pode modificar os dados da conta ou transferir SOL entre contas.
   
      Ok(())
   }

5. Compile Seu Programa

   Use o seguinte comando para compilar o programa Solana:

   cargo build-bpf

   O programa compilado será encontrado no diretório target/deploy/meu_programa.so.

Implantando Seu Programa Solana

1. Defina o Cluster Solana

   Defina o cluster no qual você gostaria de implantar. Você pode implantar na devnet para fins de teste:

   solana config set --url https://api.devnet.solana.com

2. Crie uma Wallet

   Se você ainda não criou uma wallet, pode criar uma com o seguinte comando:

   solana-keygen new -o ~/minhas-chaves.json

   Certifique-se de configurar a wallet para os comandos:

   solana config set --keypair ~/minhas-chaves.json

3. Solicite SOL para Testes

   Você pode precisar de alguns SOL na sua wallet para taxas de transação. Você pode solicitar um airdrop na devnet:

   solana airdrop 1

4. Implante o Programa

   Implante o programa usando o CLI da Solana:

   solana program deploy target/deploy/meu_programa.so

   Após a implantação, você receberá um ID do programa impresso no console. Salve esse ID, pois será importante para interagir com seu programa.

Interagindo com Seu Programa

Uma vez que seu programa está implantado, você frequentemente interagirá com ele usando o código do lado do cliente. Abaixo está um exemplo de como você pode interagir com o programa usando Rust.

1. Crie um Projeto Cliente

   Crie um novo projeto binário Rust para seu cliente:

   cargo new meu_cliente
   cd meu_cliente

2. Instale as Dependências do Cliente Solana

   Atualize o Cargo.toml no projeto do cliente para incluir as dependências necessárias:

   [dependencies]
   solana-sdk = "1.9.0"  # Use a versão mais recente, se disponível
   solana-client = "1.9.0"

3. Implemente a Lógica do Cliente

   No src/main.rs, implemente a lógica para conectar-se à rede Solana e chamar seu programa implantado:

   use solana_client::rpc_client::RpcClient;
   use solana_sdk::{signature::Keypair, signer::Signer};
   use solana_sdk::transaction::Transaction;
   
   fn main() {
      let client = RpcClient::new("https://api.devnet.solana.com");
      let payer = Keypair::from_file("/caminho/para/sua/wallet.json").expect("Falha ao carregar a chave.");
   
      // Exemplo: Enviar uma instrução de transação
      // Aqui você criaria uma transação que interage com seu programa implantado.
   
      // Nota: As instruções reais e a lógica do programa devem ser definidas.
   }

4. Execute Seu Cliente

   Use o Cargo para rodar sua aplicação cliente:

   cargo run

Conclusão

Nesta aula, cobrimos os fundamentos de como construir e implantar um programa Solana simples escrito em Rust. Também criamos uma aplicação cliente para interagir com nosso programa implantado. Sinta-se à vontade para expandir esse projeto implementando funcionalidades adicionais e explorando o ecossistema Solana! Boas codificações!

Navigation