13.11.2024

Lição: 019: Interação Cliente-Servidor no Solana

Nesta aula, vamos explorar como criar uma interação simples cliente-servidor na blockchain Solana. Vamos focar na construção de um cliente Solana utilizando Rust, que interagirá com um contrato inteligente implantado na Solana. Isso ajudará você a entender como enviar transações e lidar com respostas entre o cliente e o servidor.

Pré-requisitos

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

• Linguagem de programação Rust
• Cargo (gerenciador de pacotes do Rust)
• Ferramentas CLI do Solana
• Uma conta Solana existente com alguns SOL de teste (se você estiver usando o devnet)

Você pode configurar um ambiente Solana seguindo a documentação oficial.

Configurando Seu Projeto Rust

Primeiro, crie um novo projeto Rust:

cargo new solana_client
cd solana_client

Adicione as dependências necessárias no seu arquivo Cargo.toml:

[dependencies]
solana-client = "1.9.0"
solana-sdk = "1.9.0"
tokio = { version = "1", features = ["full"] }

Criando o Cliente Solana

Usaremos as bibliotecas do Cliente Solana para construir nosso cliente. No seu arquivo src/main.rs, inclua o seguinte código:

use solana_client::rpc_client::RpcClient;
use solana_sdk::signature::{Keypair, Signer};
use solana_sdk::transport::{Result, TransportError};
use std::rc::Rc;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<()> {
    // Conectar ao devnet do Solana
    let client = RpcClient::new("https://api.devnet.solana.com");

    // Gerar um novo par de chaves para a transação
    let payer = Keypair::new();

    // Obter o saldo do pagador
    let balance = client.get_balance(&payer.pubkey()).await?;
    println!("Saldo do pagador: {} lamports", balance);

    Ok(())
}

Análise do Código

1. Conectando à Rede Solana: Conectamos ao devnet do Solana usando o RpcClient fornecido pela crate solana-client.

2. Gerando um Par de Chaves: Geramos um novo par de chaves que representa a conta que enviará as transações.

3. Verificando o Saldo da Conta: Usando o método get_balance, consultamos o saldo da conta do pagador.

Enviando uma Transação

Agora que temos nosso cliente básico configurado, vamos enviar uma transação. Para isso, assumiremos que você tem um contrato inteligente implantado. Precisaremos do ID do programa e dos dados da transação.

use solana_sdk::{system_instruction, transaction::Transaction};

#[tokio::main]
async fn main() -> Result<()> {
    // código anterior aqui...

    // Chave pública do remetente (atualize com a chave pública real do remetente)
    let sender = payer.pubkey();
    // Chave pública do destinatário (substitua por um endereço de destinatário real)
    let receiver = Keypair::new().pubkey(); // Isso deve apontar para o destinatário real

    // Criar uma instrução de transferência (1 SOL = 1_000_000_000 lamports)
    let instruction = system_instruction::transfer(&sender, &receiver, 1_000_000_000); // enviar 1 SOL

    // Criar e assinar a transação
    let recent_blockhash = client.get_recent_blockhash().await?.0;
    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&sender));
    transaction.sign(&[&payer], recent_blockhash);

    // Enviar a transação
    let signature = client.send_and_confirm_transaction(&transaction).await?;
    println!("Transação bem-sucedida com a assinatura: {:?}", signature);

    Ok(())
}

Análise do Código da Transação

1. Instrução de Transferência: Criamos uma instrução de transferência usando system_instruction::transfer. Você precisa especificar o remetente, destinatário e o valor em lamports.

2. Criando uma Transação: Criamos uma nova transação e buscamos o blockhash mais recente.

3. Assinando a Transação: A transação deve ser assinada pelo remetente. Também fornecemos o blockhash mais recente durante a assinatura.

4. Enviando a Transação: Usamos send_and_confirm_transaction para enviar a transação e aguardar a confirmação.

Conclusão

Nesta aula, aprendemos como configurar um cliente básico Solana usando Rust e interagir com a blockchain Solana. Exploramos como conectar-se à rede Solana, verificar saldos de contas e enviar transações para um contrato inteligente.

Este é um passo fundamental na construção de aplicativos descentralizados mais complexos na blockchain Solana. À medida que você se familiariza mais com o ecossistema Solana, pode explorar recursos mais avançados, como lidar com estruturas de contas complexas, interagir com vários programas e gerenciar estados.

Bons códigos!

Navigation