15.11.2024

Aula 032: Implementando Programas Atualizáveis na Solana

Nesta aula, vamos explorar como implementar programas atualizáveis na blockchain Solana usando Rust. Programas atualizáveis permitem que desenvolvedores implantem novas versões de seus contratos inteligentes sem precisar alterar o endereço do programa nas contas que interagem com ele.

Compreendendo Programas Atualizáveis

Na Solana, programas atualizáveis são baseados no conceito de um "Endereço de Programa" que pode apontar para qualquer código executável. Quando queremos atualizar a lógica de um programa implantado, podemos fazê-lo sem modificar o endereço do programa. Isso permite que correções de bugs, aprimoramentos de funcionalidades e outras atualizações sejam aplicadas de maneira tranquila.

Componentes Principais

1. Endereços Derivados de Programas (PDAs): Esses são endereços gerados de forma determinística a partir da chave pública de um programa, permitindo que o programa gerencie seu estado.
2. Autoridade de Atualização: Uma conta designada como a autoridade que controla as atualizações do programa.
3. Carregador BPF: O carregador BPF da Solana é responsável por implantar e atualizar programas.

Configurando Seu Ambiente

Antes de começarmos a codificar, certifique-se de que você tenha o conjunto de ferramentas da Solana instalado, juntamente com a cadeia de ferramentas do Rust. Você pode seguir as instruções para configurar seu ambiente na documentação oficial da Solana.

Estrutura do Projeto

Crie um novo projeto de programa Solana usando o seguinte comando:

cargo new --lib programa_atualizavel
cd programa_atualizavel

Adicione as dependências necessárias em Cargo.toml:

[dependencies]
solana-program = "1.10.32"  # Use a versão mais recente até a data deste texto

Escrevendo Seu Programa

Vamos criar um exemplo simples de um programa atualizável que mantém um contador. O programa terá duas versões: uma que incrementa o contador em 1 e outra que incrementa por um valor configurável.

Versão 1: Contador Simples

Crie src/lib.rs e implemente a lógica básica do contador:

use anchor_lang::prelude::*;

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

    pub fn inicializar(ctx: Context<Inicializar>, valor_inicial: u64) -> ProgramResult {
        let contador = &mut ctx.accounts.contador;
        contador.valor = valor_inicial;
        Ok(())
    }

    pub fn incrementar(ctx: Context<Incrementar>) -> ProgramResult {
        let contador = &mut ctx.accounts.contador;
        contador.valor += 1;
        Ok(())
    }
}

#[account]
pub struct Contador {
    pub valor: u64,
}

#[derive(Accounts)]
pub struct Inicializar<'info> {
    #[account(init, payer = usuario, space = 8 + 8)]
    pub contador: Account<'info, Contador>,
    #[account(mut)]
    pub usuario: Signer<'info>,
    pub sistema_programa: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Incrementar<'info> {
    #[account(mut)]
    pub contador: Account<'info, Contador>,
}

Compilando e Implantando o Programa

Execute os seguintes comandos para compilar e implantar seu programa:

cargo build-bpf
solana program deploy target/deploy/programa_atualizavel.so

Atualizando o Programa

Agora, vamos implementar uma versão atualizada de nosso programa que nos permite incrementar o contador por um valor configurável.

Versão 2: Incremento Configurável

Adicione um novo método para incrementar o contador por um valor especificado:

pub fn incrementar_por(ctx: Context<IncrementarPor>, quantidade: u64) -> ProgramResult {
    let contador = &mut ctx.accounts.contador;
    contador.valor += quantidade;
    Ok(())
}

#[derive(Accounts)]
pub struct IncrementarPor<'info> {
    #[account(mut)]
    pub contador: Account<'info, Contador>,
}

Recompilando e Implantando o Programa Atualizado

Após fazer as mudanças necessárias, recompilhe e implante o programa atualizado:

cargo build-bpf
solana program deploy target/deploy/programa_atualizavel.so --upgrade

Usando a Autoridade de Atualização

Para realizar a atualização, você deve ter uma autoridade de atualização que irá autorizar a nova versão do programa. Ao implantar o programa atualizado, você pode especificar a autoridade com a flag --upgrade.

Testando Seu Programa

Após implantar ambas as versões de seu programa, você pode usar a CLI da Solana ou programas clientes para interagir com o contador. Certifique-se de testar ambos os métodos de incremento para verificar se funcionam corretamente após a atualização.

Exemplo de Interação

1. Implemente e inicialize um contador.
2. Chame o método incrementar.
3. Atualize o programa.
4. Chame o método incrementar_por.

Conclusão

Nesta aula, exploramos como implementar e atualizar programas na blockchain Solana. Programas atualizáveis proporcionam flexibilidade e aumentam a capacidade de manter e melhorar contratos inteligentes ao longo do tempo. Certifique-se de seguir as melhores práticas na gestão de autoridades de atualização e sempre teste suas atualizações em um ambiente controlado.

Boa codificação!

Navigation