html

Punto del curso de Solidity: 8.2 Manipulación de tiempos

La manipulación de tiempos en Solidity es una técnica crucial, principalmente porque muchos contratos inteligentes requieren algún tipo de lógica basada en el tiempo. Desde subastas y préstamos hasta aperturas de inversión en fondos, los desarrolladores necesitan manejar los períodos de tiempo con precisión. A continuación, cubriremos diferentes aspectos y técnicas para manipular el tiempo en Solidity junto con ejemplos detallados y código comentado.

1. Contexto y Consideraciones

En Solidity, el tiempo se maneja mediante el uso de la variable global block.timestamp. Este valor devuelve el tiempo de Unix en segundos del momento en que se mina el bloque en el que se ejecuta la transacción. Otro punto importante es que block.timestamp puede ser influenciado por los mineros (dentro de ciertos límites), por lo que no se debe depender absolutamente de su precisión.

¿Qué es el Tiempo de Unix

Es una medida del tiempo que representa el número de segundos transcurridos desde el 00:00:00 UTC del 1 de enero de 1970.

2. Uso de block.timestamp

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

contract TimeExample {
    // Almacenar el tiempo de inicio del contrato
    uint256 public deploymentTime
    
    // Constructor para establecer el tiempo de despliegue
    constructor() {
        deploymentTime = block.timestamp
    }
    
    // Función para verificar si cierto tiempo ha pasado desde el despliegue del contrato
    function hasOneHourPassed() public view returns (bool) {
        // 1 hora = 3600 segundos
        if (block.timestamp >= deploymentTime   3600) {
            return true
        } else {
            return false
        }
    }
}

En el ejemplo anterior, almacenamos el tiempo de despliegue del contrato en una variable deploymentTime. Además, tenemos una función hasOneHourPassed que comprueba si ha pasado una hora desde el momento del despliegue.

3. Manipulación de Diferencias de Tiempo

Es común necesitar trabajar con diferencias de tiempo para implementar funcionalidades como retrasos, cronómetros o eventos basados en tiempo.

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

contract TimedEvent {
    uint256 public eventTime

    // Establecer un evento para algún tiempo en el futuro
    function setEvent(uint256 _secondsFromNow) public {
        eventTime = block.timestamp   _secondsFromNow
    }

    // Verificar si el evento está listo para ser ejecutado
    function isEventReady() public view returns (bool) {
        return block.timestamp >= eventTime
    }
}

El contrato TimedEvent permite establecer un evento que ocurrirá en un tiempo específico futuro. La función setEvent toma un valor en segundos y lo añade al block.timestamp actual para establecer el eventTime. La función isEventReady comprueba si la hora actual es igual o posterior a la de eventTime, lo que indica que el evento está listo para ser ejecutado.

4. Ejemplo de subasta con tiempo límite

Uno de los casos de uso más comunes para la manipulación de tiempos en Solidity es la creación de subastas con un tiempo límite.

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

contract Auction {
    address public highestBidder
    uint256 public highestBid
    uint256 public endTime

    // Evento para anunciar nuevas pujas
    event NewBid(address bidder, uint256 amount)
    
    // Constructor que establece la duración de la subasta
    constructor(uint256 _durationInMinutes) {
        endTime = block.timestamp   (_durationInMinutes  60)
    }
    
    // Función para hacer una puja
    function bid() public payable {
        require(block.timestamp < endTime, Auction has already ended.)
        require(msg.value > highestBid, There already is a higher bid.)

        highestBidder = msg.sender
        highestBid = msg.value
        
        emit NewBid(msg.sender, msg.value)
    }
    
    // Función para saber si la subasta ha terminado
    function isAuctionEnded() public view returns (bool) {
        return block.timestamp >= endTime
    }
}

En el contrato Auction, establecemos la duración de la subasta en el constructor y calculamos la endTime. La función bid permite a los usuarios hacer una puja, verificando primero que la subasta no haya terminado y que la nueva puja es mayor que la puja más alta hasta el momento. También hay una función isAuctionEnded que permite comprobar si la subasta ha terminado.

Conclusión

La manipulación de tiempos en Solidity es fundamental para muchas aplicaciones descentralizadas. Hay que tener en cuenta la naturaleza variable de block.timestamp y diseñar los contratos inteligentes considerando estas limitaciones. Con las herramientas disponibles en Solidity podemos crear contratos robustos y fiables que manejan eventos basados en el tiempo de manera eficiente y segura.

Anterior…Siguiente

[mwai_chat]