####** 1. Fundamentos del reloj Sui**

¿Por qué un reloj compartido? El modelo de ejecución paralela de Sui significa:

• No hay un orden de bloqueo garantizado → no se pueden usar números de bloque ni marcas de tiempo
• Clockes unobjeto compartidoque proporciona tiempo respaldado por el consenso

Estructura central:

module sui::clock {  
    struct Clock has key {  
        id: UID,  
        timestamp_ms: u64,  
    }  
}  

Propiedades clave:

• Se actualiza cada2 segundos(configurable por los validadores)
• Precisión de milisegundos (en comparación con los bloques de aproximadamente 12 segundos de Ethereum)
• Inmutable: no se puede modificar mediante contratos

---

2. Patrones de uso practicos*

#####Verificación básica de la horaria

use sui::clock;  

public entry fn execute_if_ready(  
    clock: &Clock,  
    lock: &mut LockedAsset  
) {  
    assert!(clock.timestamp_ms >= lock.unlock_time, ELocked);  
    // Release assets  
}  

#####Cumplimiento de la fecha límite

struct Auction has key {  
    id: UID,  
    end_time: u64, // Stored as Clock timestamp  
    highest_bid: u64  
}  

public entry fn bid(  
    auction: &mut Auction,  
    clock: &Clock,  
    bid_amount: u64  
) {  
    assert!(clock.timestamp_ms < auction.end_time, EAuctionEnded);  
    // Process bid  
}  

#####Acciones con tiempo bloqueado

struct VestingSchedule has key {  
    id: UID,  
    start_time: u64,  
    cliff_duration: u64 // In milliseconds  
}  

public fun claimable_amount(  
    vesting: &VestingSchedule,  
    clock: &Clock  
): u64 {  
    let elapsed = clock.timestamp_ms - vesting.start_time;  
    // Linear vesting math  
}  

---

####3. Consideraciones avanzadas

#####Consistencia de los fragmentos

• Todos los fragmentos muestran lamisma marca horaria del relojen una transacción &Clock- Para operaciones con fragmentos cruzados, pásala como referencia a un objeto compartido

#####Optimización del gas duration_ms: u64- Almacene lostiempos relativos(p. ej.,) en lugar de los absolutos siempre que sea posible

• Reutilice la misma Clockreferencia en todas las funciones

#####Gestión de errores

const MAX_CLOCK_DRIFT_MS: u64 = 3000; // 3s tolerance  

public fun validate_clock(clock: &Clock) {  
    assert!(tx_context::epoch(ctx) == clock.epoch(), EStaleClock);  
    assert!(clock.timestamp_ms <= tx_context::now_ms(ctx) + MAX_CLOCK_DRIFT_MS, EInvalidTime);  
}  

---

####4. Estrategias de prueba

#####Se burlan de un reloj en las pruebas

#[test_only]  
fun mock_clock(timestamp_ms: u64): Clock {  
    Clock { id: test_scenario::new_object(ctx), timestamp_ms }  
}  

#[test]  
fun test_vesting() {  
    let clock = mock_clock(1000);  
    let vesting = VestingSchedule { start_time: 0, ... };  
    // Test claimable amount at t=1000  
}  

#####Pruebas de transición de época

#[test]  
fun test_clock_epoch_change() {  
    let mut scenario = test_scenario::begin(...);  
    // Advance epoch  
    test_scenario::next_epoch(&mut scenario);  
    let clock = test_scenario::take_shared<Clock>(scenario);  
    assert!(clock.epoch() == 1, EEpochError);  
}  

Si estás trabajando en una lógica urgente, como las subastas o la adjudicación de calendarios en Sui Move, el sui::clockmódulo es tu mejor forma de hacer un seguimiento del tiempo. Sui no se basa en marcas temporales de bloques como Ethereum o Solana porque su objetivo es lograr una ejecución y un paralelismo deterministas. Por eso usa unobjeto de reloj compartido, que se actualiza una vez por punto de control y te proporciona una fuente de tiempo canónica.

clock.timestampInteractúas con el tiempo leyendo este objeto de reloj compartido (normalmente pasado a funciones de entrada) mediante. Este valor se actualiza aproximadamente cada segundo y muestra la marca de tiempo actual de UNIX en segundos. Si bien no está vinculado a todos los bloques, como en EVM, es lo suficientemente preciso para casos prácticos, como el desbloqueo de fichas o el vencimiento de pujas, pero no tiene una precisión de microsegundos.

Al crear una lógica basada en el tiempo, siempreintroduce el objeto Reloj de forma explícitapara que la función Move pueda leerlo y comparar las marcas de tiempo con las fechas límite almacenadas. if current_time > unlock_time + bufferPara evitar un comportamiento rígido, usa periodos de gracia o margen de maniobra en tus comparaciones () y evita confiar en segundos exactos.

Para realizar pruebas, Sui te permiteburlarte del reloj en las pruebas unitariascreando tu propia instancia del objeto compartido con una marca de tiempo personalizada. De esta forma, puedes simular condiciones futuras sin necesidad de pasar tiempo real. Simplemente construya el reloj manualmente con un valor establecido en sus #[test]funciones.

Si te sientes limitado, es probable que se deba a la forma en que Sui protege el Reloj de las mutaciones que se producen fuera de los puntos de control. Deberás diseñar tus módulos para que utilicen marcas de tiempo como entrada y leerlas desde el objeto compartido oficial. Evita crear tu propia fuente de tiempo, ya que rompe el determinismo.

🔗 Más información sobre el módulo Sui Clock