Struct AuditEntry 

pub struct AuditEntry { /* private fields */ }

Audit trail entry with hash chain integrity

Fixed 80-byte structure as specified in RFC-0002 Section 5.4. All integers are little-endian. Layout is #[repr(C)] for deterministic serialization.

Memory Layout

Offset  Size  Field
------  ----  -----
0       8     timestamp
8       8     author_id
16      2     action_code
18      6     reserved1
24      8     details_offset
32      4     details_length
36      4     reserved2
40      32    previous_hash
72      8     reserved3
------  ----
Total:  80 bytes

Examples

use aion_context::audit::{AuditEntry, ActionCode};
use aion_context::types::AuthorId;

let entry = AuditEntry::new(
    1_700_000_000_000_000_000,
    AuthorId(1001),
    ActionCode::CommitVersion,
    100,
    27,
    [0u8; 32],
);

// Verify size
assert_eq!(std::mem::size_of_val(&entry), 80);

// Access fields
assert_eq!(entry.action_code().unwrap(), ActionCode::CommitVersion);
assert_eq!(entry.author_id(), AuthorId(1001));

Implementations

impl AuditEntry

pub const fn new( timestamp: u64, author_id: AuthorId, action_code: ActionCode, details_offset: u64, details_length: u32, previous_hash: [u8; 32], ) -> Self

Create a new audit entry

Arguments

• timestamp - Nanoseconds since Unix epoch (use SystemTime::now())
• author_id - Author performing the action
• action_code - Type of operation (see ActionCode)
• details_offset - Byte offset in string table
• details_length - Length of details string (excluding null)
• previous_hash - BLAKE3 hash of previous entry (all zeros for genesis)

Examples

use aion_context::audit::{AuditEntry, ActionCode};
use aion_context::types::AuthorId;

let entry = AuditEntry::new(
    1_700_000_000_000_000_000,
    AuthorId(1001),
    ActionCode::Verify,
    200,
    42,
    [0xAB; 32],
);

pub const fn timestamp(&self) -> u64

Get the timestamp in nanoseconds

pub const fn author_id(&self) -> AuthorId

Get the author ID

pub const fn action_code(&self) -> Result<ActionCode>

Get the action code

Errors

Returns an error if the action code is not a valid enum variant

pub const fn action_code_raw(&self) -> u16

Get the action code as raw u16 (no validation)

pub const fn details_offset(&self) -> u64

Get the details offset in string table

pub const fn details_length(&self) -> u32

Get the details string length (bytes, excluding null terminator)

pub const fn previous_hash(&self) -> &[u8; 32]

Get the previous entry hash

pub fn is_genesis(&self) -> bool

Check if this is a genesis entry (first in chain)

Genesis entries have an all-zero previous hash.

pub fn compute_hash(&self) -> [u8; 32]

Compute BLAKE3 hash of this entry

The hash includes all 80 bytes of the entry. This hash becomes the previous_hash value for the next entry in the chain.

Examples

use aion_context::audit::{AuditEntry, ActionCode};
use aion_context::types::AuthorId;

let entry = AuditEntry::new(
    1_700_000_000_000_000_000,
    AuthorId(1001),
    ActionCode::CreateGenesis,
    0,
    10,
    [0u8; 32],
);

let entry_hash = entry.compute_hash();
assert_eq!(entry_hash.len(), 32);

pub const fn as_bytes(&self) -> &[u8]

Serialize entry to bytes (little-endian)

Returns exactly 80 bytes in RFC-0002 specified format.

Safety

This function is safe because:

1. AuditEntry has #[repr(C)] for deterministic layout
2. All fields are plain-old-data (POD) types
3. The lifetime of the returned slice is tied to self
4. The size is compile-time verified to be 80 bytes

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserialize entry from bytes

Errors

Returns an error if the input is not exactly 80 bytes.

Safety

This function is safe because:

1. Length is validated to be exactly 80 bytes
2. AuditEntry is #[repr(C)] with POD fields
3. All bit patterns are valid for the field types
4. No references or complex types that need initialization

Note: Callers should validate field values (e.g., action_code) after deserialization.

pub fn validate_chain(&self, previous_entry: &Self) -> Result<()>

Validate this entry against the previous entry

Checks that:

1. The previous_hash matches the hash of previous_entry
2. The timestamp is not before the previous entry
3. Reserved fields are zero

Errors

Returns an error if validation fails.

Examples

use aion_context::audit::{AuditEntry, ActionCode};
use aion_context::types::AuthorId;

let genesis = AuditEntry::new(
    1_700_000_000_000_000_000,
    AuthorId(1001),
    ActionCode::CreateGenesis,
    0,
    10,
    [0u8; 32],
);

let genesis_hash = genesis.compute_hash();

let entry2 = AuditEntry::new(
    1_700_000_001_000_000_000,
    AuthorId(1002),
    ActionCode::CommitVersion,
    10,
    15,
    genesis_hash,
);

assert!(entry2.validate_chain(&genesis).is_ok());

Trait Implementations

impl Clone for AuditEntry

fn clone(&self) -> AuditEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuditEntry

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

Formats the value using the given formatter.

impl PartialEq for AuditEntry

fn eq(&self, other: &AuditEntry) -> 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 Copy for AuditEntry

impl Eq for AuditEntry

impl StructuralPartialEq for AuditEntry