Smart contracts

Los contratos inteligentes son nuestra garantía de transparencia y accesibilidad.

Desde aquí puedes descargar directamente los archivos de los contratos. Hemos dejado también una selección de los códigos más importantes para su análisis.

N&P token -> NyP.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract NyPToken is ERC20, Ownable, AccessControl {
    bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
    
    // Dirección de la billetera multifirma o contrato proxy
    address public multiSigWallet;

    uint256 public MAX_SUPPLY = 100000000 * 10**18; // 100 millones de tokens con 18 decimales
    uint256 public totalMinted;

    mapping(address => mapping(address => uint256)) private _allowances;

    constructor(address _multiSigWallet) ERC20("NyP", "NyP") {
        totalMinted = 0;
        _mint(msg.sender, MAX_SUPPLY); // Se suministra el suministro inicial al creador del contrato

        // Asignar el controlador inicial
        _setupRole(CONTROLLER_ROLE, msg.sender);

        // Configurar la dirección de la billetera multifirma o contrato proxy
        multiSigWallet = _multiSigWallet;
    }

    // Función para mintear nuevos tokens (solo el controlador puede hacerlo)
    function mint(address to, uint256 amount) public onlyRole(CONTROLLER_ROLE) {
        require(totalMinted + amount <= MAX_SUPPLY, "Excede el suministro maximo");
        _mint(to, amount);
        totalMinted += amount;
    }

    // Función para quemar tokens (solo el propietario puede hacerlo)
    function burn(uint256 amount) public onlyOwner {
        _burn(msg.sender, amount);
    }

// Función para permitir que una dirección gaste tokens desde otra dirección
function approve(address spender, uint256 amount) public override returns (bool) {
    _approve(msg.sender, spender, amount);
    return true;
    }

// Función para consultar la cantidad de tokens que una dirección puede gastar desde otra dirección
function allowance(address owner, address spender) public view override returns (uint256) {
    return _allowances[owner][spender];
}

// Función interna para aprobar gastos de tokens
function _approve(address owner, address spender, uint256 amount) internal override {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to the zero address");

    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
}

    // Función para asignar el controlador del contrato (solo el propietario puede hacerlo)
    function setController(address newController) public onlyOwner {
        grantRole(CONTROLLER_ROLE, newController);
    }

    // Función para revocar el controlador del contrato (solo el propietario puede hacerlo)
    function revokeController(address controller) public onlyOwner {
        revokeRole(CONTROLLER_ROLE, controller);
    }

    // Función para cambiar la dirección de la billetera multifirma o contrato proxy (solo el propietario puede hacerlo)
    function changeMultiSigWallet(address newMultiSigWallet) public onlyOwner {
        multiSigWallet = newMultiSigWallet;
    }

    // Función para transferir tokens desde la billetera multifirma o contrato proxy (solo el propietario o la billetera pueden hacerlo)
    function transferFromMultiSig(address to, uint256 amount) public {
        require(msg.sender == owner() || msg.sender == multiSigWallet, "No tiene permiso para transferir");
        _transfer(owner(), to, amount);
    }
}

Funciones de propietario -> contracts/2_Owner.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "hardhat/console.sol";

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;

    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);

    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }

    /**
     * @dev Set contract deployer as owner
     */
    constructor() {
        console.log("Owner contract deployed by:", msg.sender);
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}