SwiftHTML & CSSSolidityDesenvolvimento de JogosSolana/Rust
14.11.2024

Lição: 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!

Did you like this article? Rate it from 1 to 5:

Thank you for voting!