15.11.2024

Lição: 031: Implementando Tipos de Errores Personalizados em Programas Solana

Ao desenvolver programas Solana (também conhecidos como contratos inteligentes), é crucial gerenciar erros de forma eficaz. Oferecer mensagens de erro claras e significativas pode aprimorar bastante o processo de depuração e melhorar a experiência do usuário. Nesta aula, vamos discutir como implementar tipos de erros personalizados em programas Solana usando a linguagem de programação Rust.

Por que Usar Tipos de Erros Personalizados?

Os tipos de erros personalizados nos permitem definir condições de erro específicas relevantes para o domínio da nossa aplicação. Usar erros personalizados pode:

• Melhorar a legibilidade do código.
• Fornecer feedback específico relacionado a diferentes cenários de falha.
• Ajudar desenvolvedores e usuários a entender o que deu errado durante a execução.

Configurando o Ambiente

Para acompanhar, certifique-se de que você tem o conjunto de ferramentas Solana instalado e configurado em sua máquina. Você pode fazer isso seguindo a documentação oficial do Solana.

Em seguida, crie um novo projeto Solana:

cargo new meu_programa_solana --lib
cd meu_programa_solana

Adicionando Dependências

Para implementar erros personalizados em Solana, usaremos a crate thiserror, que simplifica o manuseio de erros em Rust. Adicione as seguintes dependências ao seu arquivo Cargo.toml:

[dependencies]
solana-sdk = "1.10" # ou a versão mais recente
thiserror = "1.0"

Definindo Tipos de Erro Personalizados

Agora, vamos definir nosso tipo de erro personalizado. Crie um novo arquivo chamado error.rs no diretório src. Veja como você pode estruturar seus tipos de erro:

// src/error.rs

use thiserror::Error;

/// Tipo de erro personalizado para nosso programa Solana.
#[derive(Error, Debug)]
pub enum MyProgramError {
    #[error("Instrução inválida fornecida.")]
    InvalidInstruction,

    #[error("Fundos insuficientes.")]
    InsufficientFunds,

    #[error("Conta não inicializada.")]
    UninitializedAccount,

    #[error("Erro inesperado: {0}")]
    Other(String),
}

Neste exemplo, definimos diferentes variantes de MyProgramError, cada uma representando uma condição de erro única. As descrições fornecem contexto sobre o que deu errado.

Retornando Erros Personalizados na Lógica do Programa

Em seguida, incorporaremos nosso tipo de erro personalizado na lógica do programa. Abra o arquivo lib.rs e modifique o programa para retornar nossos erros personalizados.

Aqui está um exemplo de um manipulador de instruções simples do Solana que utiliza os tipos de erro personalizados:

// src/lib.rs

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint::ProgramResult,
    entrypoint,
    program_error::ProgramError,
    pubkey::Pubkey,
};

mod error;
use error::MyProgramError;

#[entrypoint]
pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    let accounts_iter = &mut accounts.iter();
    let _account = next_account_info(accounts_iter)?;

    // Simulando uma condição onde um erro pode ocorrer.
    if instruction_data.is_empty() {
        return Err(MyProgramError::InvalidInstruction.into());
    }

    // Lógica adicional...
    Ok(())
}

Na função process_instruction, verificamos se instruction_data está vazia. Se estiver, retornamos o erro personalizado InvalidInstruction. Convertendo nosso erro personalizado em ProgramError usando .into().

Tratando Erros no Código do Cliente

Ao interagir com o programa a partir de um cliente, realizar o tratamento de erros se torna essencial. Aqui está um breve exemplo de como você pode tratar esses erros usando o código do cliente:

// src/main.rs

use meu_programa_solana::{process_instruction, MyProgramError};

fn main() {
    let result = process_instruction(...);

    match result {
        Ok(_) => println!("Instrução processada com sucesso."),
        Err(e) => match e {
            MyProgramError::InvalidInstruction => {
                println!("Erro: Instrução inválida fornecida.");
            },
            MyProgramError::InsufficientFunds => {
                println!("Erro: Fundos insuficientes.");
            },
            MyProgramError::UninitializedAccount => {
                println!("Erro: Conta não inicializada.");
            },
            MyProgramError::Other(msg) => {
                println!("Outro erro: {}", msg);
            },
        },
    }
}

No código do cliente, correspondemos o erro às variantes de erro personalizadas, permitindo respostas específicas para cada tipo de erro.

Conclusão

Nesta aula, aprendemos como implementar tipos de erros personalizados em nossos programas Solana usando Rust. Definir erros claros e específicos melhora a legibilidade do código e a experiência do usuário. Ao usar a crate thiserror, simplificamos o tratamento de erros, tornando nosso código mais limpo e fácil de manter.

Experimente diferentes tipos de erros e seu tratamento em seus programas Solana para se tornar mais confortável com esse aspecto essencial do desenvolvimento!

Navigation