15.11.2024

Lição: 035: Padrões de Design de Programas Solana

Nesta aula, vamos explorar alguns padrões de design comuns usados no desenvolvimento de programas Solana. Solana é uma blockchain de alto desempenho que oferece uma abordagem única para a construção de aplicativos descentralizados (dApps). Compreender os padrões de design pode ajudá-lo a criar programas mais eficientes e fáceis de manter.

1. O Padrão de Estado

O Padrão de Estado é útil para gerenciar o estado de seu programa Solana. Usar uma única conta para rastrear diferentes estados pode manter seu código organizado e facilita a gestão de transições entre estados.

Exemplo

use solana_program::program_pack::{IsInitialized, Pack, Sealed};
use solana_program::pubkey::Pubkey;
use solana_program::account_info::AccountInfo;
use borsh::{BorshDeserialize, BorshSerialize};

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct Estado {
    pub inicializado: bool,
    pub estado_atual: u8,
}

impl Sealed for Estado {}
impl IsInitialized for Estado {
    fn is_initialized(&self) -> bool {
        self.inicializado
    }
}

// Função para inicializar o estado
pub fn inicializar(conta: &AccountInfo) -> ProgramResult {
    let mut estado = Estado {
        inicializado: true,
        estado_atual: 0,
    };
    estado.serialize(&mut &mut conta.data.borrow_mut()[..])?;
    Ok(())
}

// Função para atualizar o estado
pub fn atualizar_estado(conta: &AccountInfo, novo_estado: u8) -> ProgramResult {
    let mut estado = Estado::try_from_slice(&conta.data.borrow())?;
    estado.estado_atual = novo_estado;
    estado.serialize(&mut &mut conta.data.borrow_mut()[..])?;
    Ok(())
}

2. O Padrão de Comando

O Padrão de Comando encapsula uma solicitação como um objeto, permitindo a parametrização e o enfileiramento de solicitações. No Solana, isso é útil para separar diferentes comandos ou ações que podem ser realizadas em uma conta ou conjunto de contas.

Exemplo

pub enum Comando {
    CriarConta { proprietario: Pubkey },
    Transferir { quantidade: u64 },
    FecharConta,
}

pub fn executar_comando(comando: Comando, info_conta: &AccountInfo) -> ProgramResult {
    match comando {
        Comando::CriarConta { proprietario } => {
            // Lógica para criar uma conta
            // ...
        }
        Comando::Transferir { quantidade } => {
            // Lógica para transferir tokens
            // ...
        }
        Comando::FecharConta => {
            // Lógica para fechar uma conta
            // ...
        }
    }
}

3. O Padrão de Observador

O Padrão de Observador permite que um objeto notifique outros objetos interessados sobre mudanças em seu estado. Isso é útil em programas Solana onde vários módulos precisam responder ao estado da blockchain ou do programa.

Exemplo

pub struct Observador {
    pub id: Pubkey,
}

pub struct Sujeito {
    pub observadores: Vec<Observador>,
}

impl Sujeito {
    pub fn anexar(&mut self, observador: Observador) {
        self.observadores.push(observador);
    }

    pub fn notificar(&self, estado: &Estado) {
        for observador in &self.observadores {
            // Notificar cada observador da mudança de estado
            // Por exemplo, enviar uma transação ou registrar o estado
            msg!("Observador {:?} notificado com o estado {:?}", observador.id, estado);
        }
    }
}

4. O Padrão de Fábrica

O Padrão de Fábrica permite a criação de objetos sem especificar a classe exata do objeto que será criado. Isso pode ser benéfico ao lidar com diferentes tipos de contas ou configurações dentro de seu programa Solana.

Exemplo

pub enum TipoConta {
    Mint,
    Token,
}

pub struct FábricaDeContas;

impl FábricaDeContas {
    pub fn criar_conta(tipo_conta: TipoConta) -> Conta {
        match tipo_conta {
            TipoConta::Mint => {
                // Lógica para criar uma conta Mint
                Conta::ContaMint { /* campos */ }
            }
            TipoConta::Token => {
                // Lógica para criar uma conta Token
                Conta::ContaToken { /* campos */ }
            }
        }
    }
}

Conclusão

Compreender esses padrões de design aprimorará sua capacidade de escrever códigos eficientes e manuteníveis nos programas Solana. Esses padrões ajudam a estruturar seu código, gerenciar estados e lidar com interações entre os vários componentes de suas dApps. À medida que você desenvolve suas aplicações Solana, considere como você pode incorporar esses padrões em seu design de programa. Boa codificação!

Navigation