18.11.2024

aula 061: Controle de Acesso Programático no Solana

Nesta aula, vamos explorar o controle de acesso programático no Solana, especificamente como gerenciar permissões e restringir o acesso a funções específicas de um contrato inteligente. O controle de acesso é um aspecto crucial no desenvolvimento de aplicativos descentralizados, pois garante que apenas entidades autorizadas possam realizar certas ações.

Entendendo o Controle de Acesso

O controle de acesso geralmente envolve a definição de papéis e permissões para diferentes usuários ou entidades que interagem com o contrato inteligente. No Solana, podemos implementar o controle de acesso das seguintes maneiras:

1. Administradores Codificados: Definir um usuário específico (por exemplo, um administrador) que tenha acesso exclusivo a certas funções.
2. Controle de Acesso Baseado em Papéis: Definir múltiplos papéis com diferentes permissões.
3. Acesso Baseado em Token: Usar tokens para conceder permissões para ações específicas.

Nesta aula, implementaremos um mecanismo simples de controle de acesso com administrador codificado.

Configurando o Projeto

Se você ainda não configurou seu ambiente de desenvolvimento do Solana, siga estes passos para criar um novo programa do Solana:

1. Instale o Rust toolchain se você ainda não fez isso.
2. Instale o CLI do Solana.
3. Crie um novo diretório para o seu programa Solana e construa-o:

cargo new --lib exemplo_controle_acesso
cd exemplo_controle_acesso

4. Adicione dependências em Cargo.toml:

[dependencies]
solana-program = "1.10"

5. Crie a estrutura de pastas necessária:

mkdir src
touch src/lib.rs

Implementando o Controle de Acesso

Agora, vamos implementar o controle de acesso em nosso programa Solana. Aqui está um exemplo básico:

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

pub struct ControleAcesso {
    admin: Pubkey,
}

impl ControleAcesso {
    pub fn new(admin: Pubkey) -> Self {
        ControleAcesso { admin }
    }

    pub fn eh_admin(&self, user: &Pubkey) -> bool {
        self.admin == *user
    }

    pub fn funcao_restrita(&self, user: &Pubkey, dados: &str) -> ProgramResult {
        if self.eh_admin(user) {
            // Executa a ação apenas se o usuário for admin
            println!("Ação do admin executada com dados: {}", dados);
            Ok(())
        } else {
            Err(ProgramError::MissingRequiredSignature)
        }
    }
}

Exemplo de Uso

Agora, digamos que você queira chamar a funcao_restrita e verificar o acesso do admin. Aqui está como você poderia implementar isso:

#[cfg(not(feature = "sem-ponto-de-entrada"))]
mod ponto_de_entrada {
    use super::*;
    use solana_program::entrypoint::Program;
    use solana_program::msg;

    #[inline(always)]
    pub fn processar_instrucao(
        program_id: &Pubkey,
        contas: &[AccountInfo],
        dados_instrucao: &[u8],
    ) -> ProgramResult {
        let chave_pub_admin = contas[0].key; // Assume que a primeira conta é o admin
        let chave_pub_user = contas[1].key; // Assume que a segunda conta é o usuário

        let controle_acesso = ControleAcesso::new(*chave_pub_admin);

        // Convertendo os dados da instrução para string para demonstração
        let dados = String::from_utf8_lossy(dados_instrucao).to_string();

        match controle_acesso.funcao_restrita(chave_pub_user, &dados) {
            Ok(_) => msg!("Ação executada com sucesso"),
            Err(e) => msg!("Erro ao executar a ação: {:?}", e),
        }

        Ok(())
    }
}

Implantando o Programa

1. Compile seu programa:

cargo build-bpf

2. Implemente o programa compilado no cluster Solana usando o CLI do Solana. Certifique-se de prestar atenção na rede apropriada (devnet/testnet/mainnet).

solana program deploy /caminho/para/seu/arquivo.so

3. Chame o programa de um cliente. Você pode criar um cliente que envia a chave pública do usuário e a chave pública do admin para testar o controle de acesso. Você pode usar utilitários fornecidos nas bibliotecas do programa Solana ou criar um cliente JavaScript simples com @solana/web3.js.

Conclusão

Nesta aula, implementamos um mecanismo básico de controle de acesso codificado para um contrato inteligente Solana. Definimos um usuário admin que tem acesso a uma função restrita. Este é apenas um ponto de partida, e você pode expandir essa funcionalidade com mecanismos de controle de acesso mais sofisticados, incluindo sistemas baseados em papéis ou a integração de sistemas de permissão baseados em tokens.

À medida que você continua a construir aplicativos descentralizados no Solana, considere como você pode utilizar o controle de acesso para aumentar a segurança e a funcionalidade. Boa codificação!

Navigation