15.11.2024

Aula 034: Construindo Aplicações Descentralizadas (dApps) na Solana

Nesta aula, vamos explorar como construir aplicações descentralizadas (dApps) na blockchain da Solana utilizando Rust. Vamos cobrir os conceitos básicos da Solana, como configurar seu ambiente de desenvolvimento e como criar uma dApp simples que interage com a rede Solana.

Introdução à Solana

A Solana é uma blockchain de alto desempenho que suporta aplicações descentralizadas e projetos de cripto. É conhecida por suas rápidas velocidades de transação, baixas taxas e escalabilidade. A Solana utiliza um mecanismo de consenso único chamado Proof of History (PoH) para alcançar alta performance e baixa latência.

Configurando Seu Ambiente de Desenvolvimento

Antes de começarmos a construir nossa dApp, precisamos configurar nosso ambiente de desenvolvimento:

1. Instalar o Rust: Se você ainda não instalou o Rust, pode fazê-lo seguindo as instruções oficiais em rust-lang.org.

2. Instalar Anchor: Anchor é um framework para Solana que simplifica o processo de construção de dApps. Instale-o executando:

   cargo install --git https://github.com/project-serum/anchor anchor-cli --locked

3. Instalar o Conjunto de Ferramentas da Solana: A Solana fornece um conjunto de ferramentas de linha de comando necessário para interagir com a blockchain da Solana:

   sh -c "$(curl -sSfL https://release.solana.com/v1.10.32/install)"

   Substitua v1.10.32 pela versão mais recente da Solana.

4. Configurar o CLI da Solana: Configure o CLI para apontar para a devnet:

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

5. Criar um novo projeto usando Anchor:

   anchor init meu_dapp
   cd meu_dapp

Construindo uma dApp Simples

Nesta seção, vamos criar uma dApp simples de transferência de tokens que permite aos usuários enviar tokens de uma carteira para outra.

1. Escrevendo o Contrato Inteligente

Navegue até o arquivo programs/meu_dapp/src/lib.rs. Substitua o conteúdo por este código Rust:

use anchor_lang::prelude::*;

declare_id!("SeuIDdoProgramaAqui"); // Substitua pelo seu ID de programa

#[program]
pub mod meu_dapp {
    use super::*;

    pub fn transferir_tokens(ctx: Context<TransferirTokens>, quantidade: u64) -> Result<()> {
        let ix = anchor_lang::solana_program::system_instruction::transfer(
            &ctx.accounts.remetente.key(),
            &ctx.accounts.destinatario.key(),
            quantidade,
        );
        anchor_lang::solana_program::program::invoke(
            &ix,
            &[
                ctx.accounts.remetente.clone(),
                ctx.accounts.destinatario.clone(),
                ctx.accounts.programa_sistema.clone(),
            ],
        )?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct TransferirTokens<'info> {
    #[account(mut)]
    pub remetente: Signer<'info>,
    #[account(mut)]
    pub destinatario: AccountInfo<'info>,
    pub programa_sistema: Program<'info, System>,
}

2. Compilando e Desplegando o Programa

Para compilar e desplegar o programa na devnet da Solana, execute os seguintes comandos:

anchor build
anchor deploy

3. Interagindo com a dApp

Para testar a funcionalidade de transferência de tokens, vamos criar um cliente simples usando JavaScript com a biblioteca Solana Web3.js. Crie um novo diretório para o cliente e acesse-o:

mkdir meu_dapp_client
cd meu_dapp_client
npm init -y
npm install @solana/web3.js

Crie um novo arquivo transferir.js e adicione o seguinte código:

const {
    Connection,
    Keypair,
    LAMPORTS_PER_SOL,
    SystemProgram,
    Transaction
} = require('@solana/web3.js');

const connection = new Connection('https://api.devnet.solana.com', 'confirmed');

async function transferirTokens(remetente, destinatario, quantidade) {
    const transaction = new Transaction().add(
        SystemProgram.transfer({
            fromPubkey: remetente.publicKey,
            toPubkey: destinatario,
            lamports: quantidade * LAMPORTS_PER_SOL,
        })
    );

    const signature = await connection.sendTransaction(transaction, [remetente]);
    await connection.confirmTransaction(signature);
    console.log('Transferência realizada com sucesso com a assinatura:', signature);
}

(async () => {
    const remetente = Keypair.generate();
    const destinatario = Keypair.generate();

    // Financiar o remetente com algum SOL para testes
    const airdropSignature = await connection.requestAirdrop(remetente.publicKey, 1 * LAMPORTS_PER_SOL);
    await connection.confirmTransaction(airdropSignature);

    console.log('Saldo do remetente:', await connection.getBalance(remetente.publicKey) / LAMPORTS_PER_SOL);
    console.log('Saldo do destinatário antes da transferência:', await connection.getBalance(destinatario.publicKey) / LAMPORTS_PER_SOL);

    await transferirTokens(remetente, destinatario.publicKey, 0.5);

    console.log('Saldo do remetente após a transferência:', await connection.getBalance(remetente.publicKey) / LAMPORTS_PER_SOL);
    console.log('Saldo do destinatário após a transferência:', await connection.getBalance(destinatario.publicKey) / LAMPORTS_PER_SOL);
})();

4. Executando o Cliente

Para executar o código do cliente, execute o seguinte comando:

node transferir.js

O script criará uma nova carteira para o remetente e outra para o destinatário, financiará o remetente e realizará uma transferência de tokens do remetente para o destinatário.

Conclusão

Nesta aula, você aprendeu como configurar seu ambiente de desenvolvimento Rust para a Solana, escrever um contrato inteligente simples de transferência de tokens usando Anchor e criar uma aplicação cliente para interagir com o contrato inteligente. Você pode construir sobre esta base para criar dApps mais avançadas na blockchain da Solana.

Na próxima aula, vamos nos aprofundar em tratamento de erros e testes de suas dApps na Solana. Boas codificações!

Navigation