State

The cron module keeps state of the following primary objects:

1. Params

2. Schedules

3. Schedule execution tracking

Params

Params is a module-wide configuration structure that stores system parameters and defines overall functioning of the cron module.

• Params: 0x01 | ProtocolBuffer(Params)

message Params {
  string security_address = 1;  // Emergency removal authority
  uint64 limit = 2;             // Max schedules executed per block
}

Schedule

Schedule defines the scheduled execution configuration.

• Schedule: 0x02 | []byte(name) | ProtocolBuffer(Schedule)

message Schedule {
  string name = 1;                         // Schedule identifier
  uint64 period = 2;                       // Execution interval in blocks
  repeated MsgExecuteContract msgs = 3;    // Messages to execute
  uint64 last_execute_height = 4;          // Last execution block height
}

ScheduleCount

ScheduleCount tracks the total number of schedules for governance limits.

• ScheduleCount: 0x03 | ProtocolBuffer(ScheduleCount)

message ScheduleCount {
  int32 count = 1;  // The number of current schedules
}

ExecutionStage

ExecutionStage controls the height offset used in schedule readiness checking:

enum ExecutionStage {
  EXECUTION_STAGE_END_BLOCKER = 0;   // Check schedules ready for next block (height + 1)
  EXECUTION_STAGE_BEGIN_BLOCKER = 1; // Check schedules ready for current block (height + 0)
}

Height Offset Logic in intervalPassed function:

func (k *Keeper) intervalPassed(ctx sdk.Context, schedule types.Schedule, executionStage types.ExecutionStage) bool {
    delta := 0
    if executionStage == types.ExecutionStage_EXECUTION_STAGE_END_BLOCKER {
        delta = 1  // Add 1 to current height for next block readiness check
    }
    return uint64(ctx.BlockHeight())+uint64(delta) >= (schedule.LastExecuteHeight + schedule.Period)
}

Usage in Message Retrieval:

• EXECUTION_STAGE_END_BLOCKER: Checks if schedules will be ready in the next block (for hash calculation)

• EXECUTION_STAGE_BEGIN_BLOCKER: Checks if schedules are ready in the current block (for immediate execution)

Cross-Block State (tm-secret-enclave)

The cron module also maintains state across block boundaries using the tm-secret-enclave component:

Implicit Hash Storage

// Global hash storage with thread safety
static IMPLICIT_HASH: Mutex<[u8; 32]> = Mutex::new(DEFAULT_IMPLICIT_HASH);

This storage maintains the SHA-256 hash of scheduled messages between blocks:

• Block N-1: Hash calculated and stored during EndBlock

• Block N: Hash retrieved and included in block header

• Verification: Hash verified during message execution in enclave