Desafio :Desenvolver um contrato de consórcio

Vamos criar um desafio em Solidity para desenvolver um contrato de consórcio.

O contrato de consórcio permitirá que os participantes contribuam com um valor específico e, após um período determinado, possam adquirir uma cota do consórcio. O contrato também deve lidar com a administração e a confirmação de transações.

Aqui está um exemplo básico de como você pode estruturar esse contrato:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Consorcio {
    address public admin;
    uint256 public prazo; // prazo em segundos
    uint256 public valor; // valor da cota em wei
    uint256 public valorTotal; // valor total do consórcio
    uint256 public percentualAdministracao; // percentual de administração (0.2%)
    uint256 public quantidadeCotas;
    uint256 public dataInicio;
    uint256 public dataFim;
    
    mapping(address => uint256) public cotas;
    mapping(address => bool) public participantes;
    address[] public listaParticipantes;

    event ParticipacaoConfirmada(address participante, uint256 valorContribuido);
    event TransacaoConfirmada(address participante, uint256 valor, uint256 quantidadeCotas);
    
    constructor(
        uint256 _prazo,
        uint256 _valor,
        uint256 _valorTotal,
        uint256 _quantidadeCotas
    ) {
        admin = msg.sender;
        prazo = _prazo;
        valor = _valor;
        valorTotal = _valorTotal;
        percentualAdministracao = 20; // 0.2% como inteiro
        quantidadeCotas = _quantidadeCotas;
        dataInicio = block.timestamp;
        dataFim = dataInicio + prazo;
    }

    modifier onlyAdmin() {
        require(msg.sender == admin, "Acesso negado: Apenas o admin pode realizar esta ação");
        _;
    }

    modifier consorcioAberto() {
        require(block.timestamp < dataFim, "O consórcio foi encerrado");
        _;
    }

    function participar() external payable consorcioAberto {
        require(!participantes[msg.sender], "Participante já registrado");
        require(msg.value >= valor, "Valor enviado é menor que o valor da cota");
        
        uint256 valorComTaxa = msg.value;
        uint256 valorTaxa = (valorComTaxa * percentualAdministracao) / 10000;
        valorComTaxa -= valorTaxa;
        
        cotas[msg.sender] += 1;
        participantes[msg.sender] = true;
        listaParticipantes.push(msg.sender);
        
        payable(admin).transfer(valorTaxa);
        
        emit ParticipacaoConfirmada(msg.sender, valorComTaxa);
    }

    function confirmarTransacao() external {
        require(participantes[msg.sender], "Você não está registrado no consórcio");
        
        uint256 quantidade = cotas[msg.sender];
        uint256 valorReembolsado = valor * quantidade;
        require(address(this).balance >= valorReembolsado, "Saldo insuficiente no contrato");
        
        cotas[msg.sender] = 0;
        participantes[msg.sender] = false;
        payable(msg.sender).transfer(valorReembolsado);
        
        emit TransacaoConfirmada(msg.sender, valorReembolsado, quantidade);
    }

    function saldoContrato() external view returns (uint256) {
        return address(this).balance;
    }

    function listarParticipantes() external view returns (address[] memory) {
        return listaParticipantes;
    }
}

Explicação:

• Variáveis:

  • prazo: Duração do consórcio em segundos.

  • valor: Valor de cada cota em wei.

  • valorTotal: Valor total do consórcio.

  • percentualAdministracao: Percentual de administração (0.2% representado como 20/10000).

  • quantidadeCotas: Quantidade total de cotas disponíveis.

  • dataInicio e dataFim: Para controlar o período do consórcio.

• Funções:

  • participar(): Permite que um usuário participe do consórcio, enviando o valor da cota. Deduz a taxa de administração e registra o participante.

  • confirmarTransacao(): Permite que um participante confirme a transação e receba o valor referente às cotas.

  • saldoContrato(): Retorna o saldo atual do contrato.

  • listarParticipantes(): Retorna a lista de participantes.

Esse contrato é um ponto de partida e pode ser expandido com mais funcionalidades conforme necessário. Por exemplo, pode-se adicionar verificações adicionais, funcionalidades para calcular o valor exato da administração, e controles de segurança mais robustos.