Como criar um sistema de Cofre

Nesse artigo iremos aprender a como criar um sistema de Staking de Cofres para seu projeto, token ou jogo NFT.

Sistema de Cofres

Exemplo simples de contrato de cofre, comumente usado em protocolos DeFi.
A maioria dos cofres na rede principal são mais complexos. Aqui vamos nos concentrar na matemática para calcular as ações a serem cunhadas no depósito e a quantidade de token a ser retirada.

Como funciona o contrato de Cofre?

1. Alguma quantidade de ações é cunhada quando um usuário deposita.
2. O protocolo DeFi usaria os depósitos dos usuários para gerar rendimento (de alguma forma).
3. O usuário queima ações para retirar seus tokens + rendimento.

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

contract Vault {
    IERC20 public immutable token;

    uint public totalSupply;
    mapping(address => uint) public balanceOf;

    constructor(address _token) {
        token = IERC20(_token);
    }

    function _mint(address _to, uint _shares) private {
        totalSupply += _shares;
        balanceOf[_to] += _shares;
    }

    function _burn(address _from, uint _shares) private {
        totalSupply -= _shares;
        balanceOf[_from] -= _shares;
    }

    function deposit(uint _amount) external {
        /*
        a = quantia
        B = saldo de tokens antes do depósito
        T = total supply
        s = shares para mintar

        (T + s) / T = (a + B) / B 

        s = aT / B
        */
        uint shares;
        if (totalSupply == 0) {
            shares = _amount;
        } else {
            shares = (_amount * totalSupply) / token.balanceOf(address(this));
        }

        _mint(msg.sender, shares);
        token.transferFrom(msg.sender, address(this), _amount);
    }

    function withdraw(uint _shares) external {
        /*
        a = quantia
        B = saldo de tokens antes do saque
        T = total supply
        s = shares para queimar

        (T - s) / T = (B - a) / B 

        a = sB / T
        */
        uint amount = (_shares * token.balanceOf(address(this))) / totalSupply;
        _burn(msg.sender, _shares);
        token.transfer(msg.sender, amount);
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint);

    function balanceOf(address account) external view returns (uint);

    function transfer(address recipient, uint amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint amount);
    event Approval(address indexed owner, address indexed spender, uint amount);
}

Testar no Remix