Propiedad con Ownable
Contenido del curso
Propiedad con Ownable
Contenido del curso
Pepe Sosa
Alan Hurtarte
Luis Daniel Vieras
Pepe Sosa
José Manuel Piña Rodríguez
Carlos Rodríguez
Edward Rodriguez
Carlos Rodríguez
Luis Berenguer
Diego Quilumbaquin
Sebastian Perez
ProfesorJosé Manuel Piña Rodríguez
Andrés Muñoz
Edhu Nuñez Alvarado
Darwin Quintana
Andres Valencia
Sebastian Perez
Profesor
Nicolas Alejandro Herrera
Sebastian Perez
Profesor
Eber Laurente Lliuyacc
Sebastian Perez
ProfesorRevisando la librería, veo que al renunciar al owner lo que pasa es que se transfiere el owner del contrato a la dirección '0', por lo que entiendo que en Solidity no se puede quedar un contrato sin owner, simplemente se le asigna a 0 para que ninguna dirección sea la dueña.
Es interesante porque a partir de ahí, sería imposible reasignar el owner si no se llama a la función desde la dirección "0", elegante y sencillo.
Si, justo le dicen quemar el contrato. Te puede servir si fue vulnerado o lanzaste una nueva versión
Exactamente, se realiza para poder desarticular el contrato. En teoría esta práctica se realiza cuando el contrato se le haya encontrado alguna Vulnerabilidad o algún error de función inesperada, dado que una vez este en la mainnet se destruya y quede inutilizable.
Esas funciones para renunciar al owner se podrían usar por ejemplo si tenemos ciertos pasos previos a empezar la operación del contrato?
Digamos que hay una función que asigna tokens manualmente de acuerdo a un nivel de usuario, esto en una ICO o similar, una vez que terminó esa etapa se podría dejar al contrato trabajando en automático y para darle transparencia al asunto, inutilizar esa función de asignación manual renunciando al owner, de este modo el contrato trabajaría solo de acuerdo a las reglas programadas.
Es algo así o podría ser?
Si, seria posible esa implementación y asegurarte que otra función vital del proyecto no dependa del modificador onlyOwenr
Valiosísimo aporte :smile:
Muy buen inicio de curso, aplicando los aprendido durante las últimas clases del curso de introducción a solidity, larga vida a las clases y a la herencia
Así es @Edward.
Éste es el contrato Ownable
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
Y EL PDF DEL CURSO_?
hola Diego, entiendo que ya está subido el PDF
Aunque peligroso el método que permite renunciar al contrato se puede utilizar como mecanismo de seguridad para dejar un contrato obsoleto, algo así como quemar el contrato si se sospecha que la cuenta del dueño del contrato fue robada. ¿También me pregunto qué otros usos o bajo qué circunstancias alguien quisiera renunciar a sus permisos dentro del contrato? Igual que terrible si alguien accede a tu cuenta y renuncia a los permisos solo por hacerte daño....
Un uso es en los tokens que desean crear esa "imagen" de buena opción para invertir ya que no podran ser controlado por un owner, en juegos NFTs seguramente uno que otro podria tomar ese camino igual para dar mayor probabilidad para que inviertan ahí.
Un "contrato inteligente" debería de ser lo suficientemente inteligente como para auto-gestionarse, sin intervención de la parte humana ya que esta ultima es la da desconfianza a un proyecto porque se corrompe con facilidad, sobre todo cuando existe dinero de por medio
Hola a todos. Tengo un problema al importar la librería
Me aparece este error: ParserError: Source file requires different compiler version (current compiler is 0.8.18+commit.87f61d96.Emscripten.clang) - note that nightly builds are considered to be strictly less than the released version --> @openzeppelin/contracts/token/ERC721/ERC721.sol:4:1:
Sin embargo mi código parece estar bien, porque el pragma cubre la versión.
// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
¿Qué está pasando?
Hola Andres, prueba cambiando la versión del compilador a la misma que usa el ERC721 (puedes chequearlo en el repositorio de Github de OpenZeppelin)
Como se establece quien es el owner? Se hace al momento de deployar? Entonces la cuenta que estaba seleccionada en ese momento es el owner?
El owner lo estableces tú. En general coincide con el msg.sender que es la cuenta que está creando el contrato, pero puedes optar por otro owner si lo deseas, se hace por medio del código. Puede que la mayoría de los ejemplos que veas sean como mencionas, pero no se puede adaptar a tus necesidades.
Por qué el constructor de Ownable es diferente desde la cuenta en Github de Operzeppenin y el constructor cuando instalas la dependencia
Constructor de [Ownable en Github] (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol)
constructor(address initialOwner) { _transferOwnership(initialOwner); }
Y el constructor en la dependencia, cuando instalamos la librería es:
constructor() { _transferOwnership(_msgSender()); }
Hola Eber, lo acabo de probar y lo que veo es que la dependencia instalada está usando una versión de la librería un poco más antigua (ya que compila a 0.8.0 y la del github a 0.8.19) y esa versión no tiene parámetros en el constructor.
