21.11.2024

Lição: 092: Implementando Protocolos de Empréstimo e Tomada Emprestada

Nesta aula, iremos explorar como implementar protocolos básicos de empréstimo e tomada emprestada na blockchain Solana usando Rust. Vamos abordar os componentes essenciais envolvidos em tais protocolos, incluindo gerenciamento de colaterais, cálculos de juros e gerenciamento de estado.

Introdução a Empréstimos e Tomadas Emprestadas

Os protocolos de empréstimo e tomada emprestada permitem que os usuários emprestem seus ativos a outros em troca de juros ou que tomem emprestados ativos ao fornecer colaterais. Na Solana, podemos construir essas funcionalidades usando contratos inteligentes.

Configurando Seu Ambiente

Certifique-se de ter o conjunto de ferramentas Solana e o Rust instalados em sua máquina. Você pode criar um novo projeto usando o seguinte comando:

cargo new protocolo_empréstimo
cd protocolo_empréstimo

Adicione as dependências no seu arquivo Cargo.toml:

[dependencies]
solana-program = "1.10.32"
borsh = "0.9.1" # Para serialização

Definições de Estruturas e Enums

Vamos começar definindo as estruturas de dados necessárias para nosso protocolo de empréstimo.

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::program_pack::Pack;

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct Emprestimo {
    pub credor: Pubkey,
    pub devedor: Pubkey,
    pub valor: u64,
    pub colateral: u64,
    pub taxa_juros: f64,
    pub ativo: bool,
}

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct PoolEmpréstimo {
    pub total_empréstimos: u64,
    pub empréstimos: Vec<Emprestimo>,
}

Explicação dos Campos Chave

• A estrutura Emprestimo captura informações sobre empréstimos individuais, incluindo credor, devedor, valor, colateral, taxa de juros e status do empréstimo.
• A estrutura PoolEmpréstimo armazena o total de emprestados e uma lista de empréstimos.

Implementando Funções

Vamos implementar algumas funções principais para empréstimo e tomada emprestada.

1. Criar um Novo Empréstimo

Para criar um novo empréstimo, escreveremos um método que inicializa um registro de empréstimo.

impl PoolEmpréstimo {
    pub fn criar_empréstimo(
        &mut self,
        credor: Pubkey,
        devedor: Pubkey,
        valor: u64,
        colateral: u64,
        taxa_juros: f64,
    ) {
        let empréstimo = Emprestimo {
            credor,
            devedor,
            valor,
            colateral,
            taxa_juros,
            ativo: true,
        };

        self.empréstimos.push(empréstimo);
        self.total_empréstimos += valor;
    }
}

2. Reembolsar um Empréstimo

Esta função permite que um devedor reembolse um empréstimo e o feche.

impl PoolEmpréstimo {
    pub fn reembolsar_empréstimo(&mut self, devedor: Pubkey) -> Result<(), &'static str> {
        let indice_empréstimo = self.empréstimos.iter().position(|empréstimo| empréstimo.devedor == devedor && empréstimo.ativo);

        match indice_empréstimo {
            Some(indice) => {
                let empréstimo = &mut self.empréstimos[indice];
                empréstimo.ativo = false; // Marcar empréstimo como reembolsado
                self.total_empréstimos -= empréstimo.valor; // Ajustar total emprestado
                Ok(())
            }
            None => Err("Empréstimo não encontrado ou já reembolsado"),
        }
    }
}

3. Calcular Juros

O cálculo dos juros para um empréstimo ativo pode ser implementado da seguinte forma:

impl Emprestimo {
    pub fn calcular_juros(&self, duracao: u64) -> f64 {
        let principal = self.valor as f64;
        principal * self.taxa_juros * (duracao as f64 / 365.0) // Cálculo simples de juros
    }
}

Exemplo Completo do Programa

Abaixo está uma estrutura de programa simples que une nossas implementações:

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

pub struct ProgramaEmpréstimo;

impl ProgramaEmpréstimo {
    pub fn processar_instrução(
        program_id: &Pubkey,
        accounts: &[AccountInfo],
        instruction_data: &[u8],
    ) -> ProgramResult {
        // A implementação vai aqui
        Ok(())
    }
}

Testando o Protocolo

Você pode testar a implementação com testes unitários em uma seção separada mod testes na parte inferior do seu arquivo.

#[cfg(test)]
mod testes {
    use super::*;

    #[test]
    fn testar_criar_empréstimo() {
        let mut pool = PoolEmpréstimo { total_empréstimos: 0, empréstimos: vec![] };
        pool.criar_empréstimo(Pubkey::new_unique(), Pubkey::new_unique(), 1000, 1500, 0.05);

        assert_eq!(pool.total_empréstimos, 1000);
        assert_eq!(pool.empréstimos.len(), 1);
    }

    #[test]
    fn testar_reembolsar_empréstimo() {
        let mut pool = PoolEmpréstimo { total_empréstimos: 0, empréstimos: vec![] };
        let credor = Pubkey::new_unique();
        let devedor = Pubkey::new_unique();
        pool.criar_empréstimo(credor, devedor, 1000, 1500, 0.05);

        let resultado = pool.reembolsar_empréstimo(devedor);
        assert!(resultado.is_ok());
        assert!(!pool.empréstimos[0].ativo);
    }
}

Conclusão

Nesta aula, criamos um protocolo simples de empréstimo e tomada emprestada na blockchain Solana usando Rust. Definimos as estruturas de dados necessárias, implementamos funcionalidades principais e escrevemos testes unitários para garantir que tudo funcione como esperado. Esse conhecimento básico pode ser expandido para incluir recursos mais avançados, como taxas de juros dinâmicas e suporte a múltiplos colaterais.

Navigation