Struct ChainEvent 

pub struct ChainEvent {
    pub hash: Vec<u8>,
    pub parent_hash: Option<Vec<u8>>,
    pub event_type: String,
    pub data: Vec<u8>,
    pub timestamp: u64,
    pub description: Option<String>,
}

Chain Event

ChainEvent represents a single immutable event in an actor’s execution history. Each event is cryptographically linked to its parent through hash references, forming a tamper-evident chain of events that can be verified for integrity.

Purpose

This struct is the core building block of the audit system in Theater. It captures a specific action or state change, stores the relevant data, and maintains the cryptographic linking that ensures the integrity of the event history. Events are content-addressed, meaning they are identified by a hash of their content.

Example

use theater::chain::ChainEvent;
use theater::events::ChainEventData;

// Create an event
let data = vec![1, 2, 3, 4]; // Example binary data
let event = ChainEvent {
    hash: vec![],           // Will be filled by the system
    parent_hash: None,      // This is a root event with no parent
    event_type: "example".to_string(),
    data,
    timestamp: chrono::Utc::now().timestamp() as u64,
    description: Some("Example event".to_string()),
};

Security

The hash of each event is calculated based on its content, and each event references its parent’s hash. This creates a chain of cryptographic links that makes it impossible to modify any event without breaking the chain, allowing for verification of the entire history.

Implementation Notes

Events are serialized to JSON for storage and transmission. The Display implementation provides a human-readable representation of the event, making events easier to read in logs and debugging output.

Fields

hash: Vec<u8>

Cryptographic hash of this event’s content, used as its identifier. This is calculated based on all other fields except the hash itself.

parent_hash: Option<Vec<u8>>

Hash of the parent event, or None if this is the first event in the chain. This creates the cryptographic linking between events.

event_type: String

Type identifier for the event, used to categorize and filter events. Common types include “state_change”, “message”, “http_request”, etc.

data: Vec<u8>

The actual payload of the event, typically serialized structured data.

timestamp: u64

Unix timestamp (in seconds) when the event was created.

description: Option<String>

Optional human-readable description of the event for logging and debugging.

Trait Implementations

impl Clone for ChainEvent

fn clone(&self) -> ChainEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChainEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChainEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ChainEvent

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

Formats the value using the given formatter.

impl Hash for ChainEvent

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ChainEvent

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ChainEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ComponentType for ChainEvent

impl Eq for ChainEvent

impl Lift for ChainEvent

impl Lower for ChainEvent