13.11.2024

Aula 018: Entendendo Contas e Armazenamento de Dados na Solana

Nesta aula, vamos explorar os conceitos fundamentais de contas e armazenamento de dados na Solana. Compreender como usar contas de forma eficaz é essencial para desenvolver programas eficientes (conhecidos como contratos inteligentes) na blockchain da Solana.

O que são Contas?

Na Solana, contas são a principal forma de armazenar dados. Diferente das arquiteturas de blockchain tradicionais que costumam utilizar um modelo de estado global, a Solana adota um modelo baseado em contas. Cada conta pode armazenar dados e possui um saldo associado em SOL (o token nativo da Solana).

Principais Características das Contas

1. Armazenamento de Dados: Cada conta pode armazenar dados arbitrários, desde valores numéricos simples até estruturas complexas.
2. Propriedade: As contas são propriedade de programas, garantindo que apenas o programa que possui uma conta possa modificar seus dados.
3. Executável: Algumas contas são executáveis, significando que podem conter lógica de programa.
4. Lamports: Cada conta tem um saldo de lamports associado, que é o saldo mínimo que uma conta deve manter para permanecer isenta de aluguel.

Estrutura da Conta

Cada conta na Solana possui a seguinte estrutura:

• data: Os dados reais armazenados na conta.
• owner: A chave pública do programa que possui a conta.
• lamports: O saldo atual em lamports.
• executable: Um booleano indicando se a conta pode executar programas.
• rent_epoch: A época em que a conta foi isenta de aluguel pela última vez.

Configurando Seu Ambiente de Desenvolvimento

Para interagir com a Solana, você precisará configurar seu ambiente de desenvolvimento. Certifique-se de ter o seguinte instalado:

• Rust
• Solana CLI
• Anchor (opcional, mas altamente recomendado para um desenvolvimento mais fácil)

Criando e Gerenciando Contas

1. Criando uma Nova Conta

Para criar uma nova conta, precisamos escrever um programa Solana que aloque espaço para uma conta. Vamos começar criando a estrutura de projeto necessária.

anchor init exemplo_conta_solana
cd exemplo_conta_solana

Abra o arquivo Cargo.toml e certifique-se de incluir a dependência solana-program:

[dependencies]
solana-program = "1.9"

2. Definindo a Estrutura de Dados da Conta

Vamos definir uma estrutura simples para os dados da nossa conta. Criaremos um contador que será incrementado a cada transação.

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{pubkey::Pubkey, account_info::AccountInfo, entrypoint::ProgramResult};
use solana_program::msg;

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct ContaContadora {
    pub contagem: u64,
}

3. Criando a Conta

Agora, vamos criar uma função para inicializar essa conta:

pub fn inicializar_conta_contadora(
    accounts: &[AccountInfo],
) -> ProgramResult {
    let conta_info = &accounts[0];

    // Certifique-se de que a conta ainda não esteja inicializada
    if conta_info.data_is_empty() {
        let conta = ContaContadora { contagem: 0 };

        // Serializa os dados da conta e os salva na conta
        conta.serialize(&mut &mut conta_info.data.borrow_mut()[..])?;
        msg!("Conta contadora inicializada com contagem: {}", conta.contagem);
    } else {
        msg!("Conta contadora já está inicializada.");
    }

    Ok(())
}

4. Incrementando o Contador

A seguir, implementaremos uma função para incrementar o contador.

pub fn incrementar_contador(
    accounts: &[AccountInfo],
) -> ProgramResult {
    let conta_info = &accounts[0];

    // Certifique-se de que a conta foi inicializada
    let mut conta_contadora = ContaContadora::try_from_slice(&conta_info.data.borrow())?;

    // Incrementa a contagem
    conta_contadora.contagem += 1;

    // Salva o estado atualizado de volta na conta
    conta_contadora.serialize(&mut &mut conta_info.data.borrow_mut()[..])?;
    msg!("Contador incrementado para: {}", conta_contadora.contagem);

    Ok(())
}

5. Implantando Seu Programa

Uma vez que você tenha implementado o programa, pode compilar e implantá-lo no cluster da Solana.

anchor build
anchor deploy

Depois, você pode interagir com seu programa usando o Solana CLI ou criar um aplicativo frontend para chamar as funções inicializar_conta_contadora e incrementar_contador.

Conclusão

Nesta aula, abordamos os aspectos fundamentais das contas e do armazenamento de dados na blockchain Solana. Aprendemos como definir uma estrutura de dados, inicializar uma conta e modificar seu estado incrementando um contador.

Compreender as contas é essencial para a construção de contratos inteligentes eficientes e eficazes na Solana. À medida que você continua a desenvolver suas habilidades, foque em otimizar a leitura e a gravação de dados nas contas para melhorar o desempenho e reduzir custos de transação.

Na próxima aula, exploraremos tópicos mais avançados, como invocações entre programas e o uso do framework Anchor para um desenvolvimento de programa mais fácil. Boa codificação!

Navigation