Documentar smart contracts en Solidity

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

import "@openzeppelin/contracts/access/Ownable.sol";

/// @dev Error details thrown within TestingContractError
enum TestingContractErrorDetail {    
    INVALID_VALUE,
    INVALID_ADDRESS,
    NOT_ALLOWED,
    UNAVAILABLE_BALANCE,
    TRANSFER_FAILURE
}  

/**
* @notice For end user, this is a contract to test some NatSpec comments issues.
* @title TestingContract has some simple funtions.
* @dev Every NatSpec tag is tested in this contract
*/
contract TestingContract is Ownable {  
    
    /// @dev Emitted when currentValue is updated       
    event ValueUpdated(uint256 indexed newValue, uint256 indexed oldValue, address indexed sender);

    /// @dev Emitted when allowedAddress is updated
    event AddressUpdated(address indexed newValue, address indexed oldValue);

    /// @dev Custom error to revert when some error condition happens
    error TestingContractError(TestingContractErrorDetail details);    
    
    /// @dev value to update
    uint256 public currentValue;

    /// @dev restricted value to update
    address private allowedAddress;
    
    /**
    * @notice For end user, constructor called from contract owner.
    * @dev Constructor called from contract owner.  
    * Owner is set to caller.
    */     
    constructor() Ownable(msg.sender) {        
        currentValue = 0;        
    }    

    /**
    * @notice For end user, changes current value
    * @param currentValue_ New value to update.
    * @dev Changes current value   
    *
    * Throws TestingContractError if new value is not allowed.  
    *    
    */    
    function setCurrentValue(uint256 currentValue_) external {

        // Value not allowed
        if(currentValue_==0)
            revert TestingContractError(TestingContractErrorDetail.INVALID_VALUE);

        // Success
        emit ValueUpdated(currentValue_, currentValue, msg.sender); 
        currentValue = currentValue_;
    }

    /**
    * For end user, changes current value if requested by allowed address
    * @dev Changes current value if requested by allowed address   
    *
    * Throws TestingContractError if requested by not allowed address.  
    *
    * @param currentValue_ New value to update.
    */    
    function setCurrentValueRestricted(uint256 currentValue_) external {

        // Requestes by not allowed address
        if(msg.sender!=allowedAddress)
            revert TestingContractError(TestingContractErrorDetail.NOT_ALLOWED);

        // Success
        emit ValueUpdated(currentValue_, currentValue, msg.sender);        
        currentValue = currentValue_;
    }


    /**
    * For end user, changes allowed address
    * @dev Changes allowed address   
    *
    * Throws TestingContractError if new address is not allowed.  
    * Throws OwnableUnauthorizedAccount if caller is not contract owner.  
    *
    * @param allowedAddress_ New address to update.
    */    
    function setAllowedAddress(address allowedAddress_) external onlyOwner {

        // Not allowed address
        if(allowedAddress_== address(0))
            revert TestingContractError(TestingContractErrorDetail.INVALID_ADDRESS);

        // Success
        emit AddressUpdated(allowedAddress_, allowedAddress);
        allowedAddress = allowedAddress_;        
    }

    /**
    * For end user, withdraws all contract balance.
    * @dev Function to withdraw all contract balance.    
    *
    * Throws OwnableUnauthorizedAccount if caller is not allowed.     
    * Throws TestingContractError if there is not balance to transfer or transfer process fails.
    * See [TestingContractErrorDetail](#testingcontracterrordetail).  
    *
    * @param receiver Address to trasfer balance to.  
    */  
    function withdraw(address receiver) external onlyOwner {
        
        // No balance
        if(address(this).balance == 0) 
            revert TestingContractError(TestingContractErrorDetail.UNAVAILABLE_BALANCE);
        // Transfers balance
        bool success = payable(receiver).send(address(this).balance); 
        // Some error happened
        if(!success)  
            revert TestingContractError(TestingContractErrorDetail.TRANSFER_FAILURE);          
    }
   
    
    /// @dev To allow receiving balance
    receive() external payable {}

}