Punto del curso de Solidity: 6.1 Modificadores de funciones

Los modificadores de funciones en Solidity son una característica muy poderosa que permite cambiar el comportamiento
de las funciones de una manera limpia y reutilizable. Los modificadores pueden ser utilizados para verificar
condiciones antes de ejecutar el cuerpo de la función, para evitar duplicación de código y para mejorar la
legibilidad y mantenimiento del contrato.

Definición y uso de modificadores

Un modificador en Solidity se define utilizando la palabra clave modifier seguida del nombre del
modificador y su cuerpo. Dentro del cuerpo del modificador, la instrucción _ se usa para indicar
dónde debe insertarse el cuerpo de la función que es modificada.

pragma solidity ^0.8.0

contract Propietario {

    address owner

    // Establecer el propietario cuando el contrato es desplegado
    constructor() {
        owner = msg.sender
    }

    // Modificador que verifica si el remitente es el propietario
    modifier onlyOwner() {
        require(msg.sender == owner, No eres el propietario)
        _
    }

    // Una función que solo puede ser llamada por el propietario
    function funcionSoloPropietario() public onlyOwner {
        // Lógica de la función
    }
}
        

Explicación del código

• address owner: Declara una variable de estado llamada owner que almacenará la dirección del propietario.

• constructor(): En el constructor del contrato, se establece el propietario como la dirección que despliega el contrato (representada por msg.sender).

• modifier onlyOwner(): Define un modificador llamado onlyOwner que verifica si el remitente de la transacción es el propietario del contrato. Si no lo es, la transacción falla con un mensaje de error No eres el propietario. La instrucción _ indica dónde se insertará el cuerpo de la función que está siendo modificada.

• function funcionSoloPropietario(): Esta función utiliza el modificador onlyOwner para garantizar que solo el propietario pueda ejecutarla.

Modificadores concatenados

También es posible encadenar múltiples modificadores en una sola función. Por ejemplo, si deseas comprobar si la
función ha sido llamada por el propietario y si ciertas condiciones se cumplen, puedes definir y utilizar múltiples
modificadores de la siguiente manera:

pragma solidity ^0.8.0

contract MultiModificadores {

    address owner
    bool public active = true

    constructor() {
        owner = msg.sender
    }

    modifier onlyOwner() {
        require(msg.sender == owner, No eres el propietario)
        _
    }

    modifier isActive() {
        require(active, Contrato no está activo)
        _
    }

    function funcionMultipleModificadores() public onlyOwner isActive {
        // Lógica de la función
    }

    function toggleActive() public onlyOwner {
        active = !active
    }
}
        

Explicación del código

• modifier isActive(): Define un modificador que verifica si una variable booleana active es verdadera.

• function funcionMultipleModificadores(): Esta función está protegida por dos modificadores: onlyOwner e isActive. Primero se verifica que el remitente es el propietario y luego que el contrato está activo.

• function toggleActive(): Una función adicional para alternar el estado de la variable active, accesible solo por el propietario.

Modificadores con parámetros

Los modificadores también pueden recibir argumentos, lo que los hace aún más flexibles y reutilizables. Aquí hay
un ejemplo de un modificador que verifica si el valor de entrada es mayor que un número específico:

pragma solidity ^0.8.0

contract ConParametro {

    address owner
    uint public minAmount

    constructor(uint _minAmount) {
        owner = msg.sender
        minAmount = _minAmount
    }

    modifier onlyOwner() {
        require(msg.sender == owner, No eres el propietario)
        _
    }

    modifier minValue(uint amount) {
        require(amount >= minAmount, El monto es demasiado bajo)
        _
    }

    function actualizarMontoMinimo(uint newMinAmount) public onlyOwner {
        minAmount = newMinAmount
    }

    function realizarTransaccion(uint amount) public minValue(amount) {
        // Lógica de la función para realizar la transacción
    }
}
        

Explicación del código

• constructor(uint _minAmount): Inicializa una variable de estado minAmount con un valor mínimo recibido como parámetro.

• modifier minValue(uint amount): Este modificador recibe un parámetro amount y verifica si es mayor o igual al monto mínimo permitido.

• function realizarTransaccion(uint amount): Esta función utiliza el modificador minValue para asegurarse de que el monto de la transacción cumpla con el mínimo requerido.

• function actualizarMontoMinimo(uint newMinAmount): Una función que permite al propietario actualizar el monto mínimo.

Conclusión

Los modificadores de funciones en Solidity ofrecen una manera elegante y eficiente de aplicar restricciones y
precondiciones a las funciones del contrato. Facilitan la implementación de controles de acceso, aseguran el cumplimiento
de reglas y mejoran la mantenibilidad del código.

Como se ha visto en los ejemplos, los modificadores pueden ser simples o complejos, con o sin parámetros, y se pueden
encadenar para componer lógicas más sofisticadas. Esto permite una gran flexibilidad en el diseño de contratos inteligentes.

Anterior…Siguiente