Struct StepEntry 

pub struct StepEntry<S: Clone> {
    pub step_id: u64,
    pub timestamp: SimTime,
    pub rng_state_before: [u8; 32],
    pub rng_state_after: [u8; 32],
    pub input_state: S,
    pub output_state: S,
    pub equation_evaluations: Vec<EquationEval>,
    pub decisions: Vec<Decision>,
    pub step_type: String,
    pub compute_duration_us: u64,
}

Complete step entry for audit logging (EDD-16).

Every step MUST include all required fields for full reproducibility and verification.

Fields

step_id: u64

Monotonic step counter

timestamp: SimTime

Simulation time at this step

rng_state_before: [u8; 32]

Blake3 hash of RNG state BEFORE this step

rng_state_after: [u8; 32]

Blake3 hash of RNG state AFTER this step

input_state: S

State snapshot before step (for replay verification)

output_state: S

State snapshot after step

equation_evaluations: Vec<EquationEval>

All equation evaluations performed in this step

decisions: Vec<Decision>

All decisions made in this step

step_type: String

Step type identifier (simulation-specific)

compute_duration_us: u64

Duration of step computation (for profiling)

Implementations

impl<S: Clone + Serialize> StepEntry<S>

pub fn new( step_id: u64, timestamp: SimTime, step_type: impl Into<String>, input_state: S, output_state: S, ) -> Self

Create a new step entry.

pub fn with_rng_states(self, before: [u8; 32], after: [u8; 32]) -> Self

Set RNG state hashes.

pub fn add_equation_eval(&mut self, eval: EquationEval)

Add an equation evaluation.

pub fn add_decision(&mut self, decision: Decision)

Add a decision.

pub fn with_duration(self, duration_us: u64) -> Self

Set compute duration.

Trait Implementations

impl<S: Clone + Clone> Clone for StepEntry<S>

fn clone(&self) -> StepEntry<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + Clone> Debug for StepEntry<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for StepEntry<S>

where S: Deserialize<'de> + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> Serialize for StepEntry<S>

where S: Serialize + Clone,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.