use serde::{Deserialize, Serialize};
use crate::schema::{
Hash, ManifestId, PrivacyClass, ProvenanceRecord, SchemaRef, Timestamp, TrustEnvelope,
};
use crate::{Error, Result};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TimeBounds {
pub from: Timestamp,
pub to: Timestamp,
}
impl TimeBounds {
pub fn at(instant: Timestamp) -> Self {
Self {
from: instant,
to: instant,
}
}
pub fn is_valid(&self) -> bool {
self.from <= self.to
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Engram {
pub schema: SchemaRef,
pub payload: Vec<u8>,
pub content_hash: Hash,
pub privacy: PrivacyClass,
pub provenance: ProvenanceRecord,
pub trust: TrustEnvelope,
pub bounds: TimeBounds,
#[serde(default = "Engram::default_version")]
pub envelope_version: u32,
}
impl Engram {
pub const CURRENT_VERSION: u32 = 1;
fn default_version() -> u32 {
Self::CURRENT_VERSION
}
pub fn new(
schema: SchemaRef,
payload: Vec<u8>,
privacy: PrivacyClass,
provenance: ProvenanceRecord,
trust: TrustEnvelope,
bounds: TimeBounds,
) -> Self {
let content_hash = Hash::of(&payload);
Self {
schema,
payload,
content_hash,
privacy,
provenance,
trust,
bounds,
envelope_version: Self::CURRENT_VERSION,
}
}
pub fn id(&self) -> ManifestId {
ManifestId::from_hash(self.content_hash)
}
pub fn verify_integrity(&self) -> Result<()> {
let actual = Hash::of(&self.payload);
if actual != self.content_hash {
return Err(Error::new(format!(
"engram integrity check failed: declared {}, computed {}",
self.content_hash, actual
)));
}
if !self.bounds.is_valid() {
return Err(Error::new(format!(
"engram time bounds invalid: from={:?} > to={:?}",
self.bounds.from, self.bounds.to
)));
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::schema::{
ManifestId, ModerationState, ProvenanceOrigin, ProvenanceRecord, SchemaRef, Timestamp,
TrustLevel,
};
fn test_schema_ref() -> SchemaRef {
SchemaRef::from_id(ManifestId::of_blob(b"test-schema"))
}
fn fresh_engram(payload: Vec<u8>) -> Engram {
Engram::new(
test_schema_ref(),
payload,
PrivacyClass::LocalOnly,
ProvenanceRecord {
origin: ProvenanceOrigin::Generated,
upstream: Vec::new(),
tooling: Some("eidetic-test/0.0.1".to_string()),
generated_at: Timestamp(1_700_000_000_000),
},
TrustEnvelope {
level: TrustLevel::SelfAsserted,
signatures: Vec::new(),
moderation_state: ModerationState::Unreviewed,
},
TimeBounds::at(Timestamp(1_700_000_000_000)),
)
}
#[test]
fn new_engram_passes_integrity_check() {
let engram = fresh_engram(b"hello".to_vec());
engram.verify_integrity().unwrap();
}
#[test]
fn tampered_payload_fails_integrity_check() {
let mut engram = fresh_engram(b"hello".to_vec());
engram.payload = b"world".to_vec();
let result = engram.verify_integrity();
assert!(result.is_err());
assert!(format!("{}", result.unwrap_err()).contains("integrity check failed"));
}
#[test]
fn invalid_time_bounds_are_rejected() {
let mut engram = fresh_engram(b"x".to_vec());
engram.bounds = TimeBounds {
from: Timestamp(2_000_000_000_000),
to: Timestamp(1_000_000_000_000),
};
let result = engram.verify_integrity();
assert!(result.is_err());
assert!(format!("{}", result.unwrap_err()).contains("time bounds invalid"));
}
#[test]
fn engram_id_equals_manifest_id_of_payload() {
let payload = b"matching-id".to_vec();
let engram = fresh_engram(payload.clone());
assert_eq!(engram.id(), ManifestId::of_blob(&payload));
}
#[test]
fn engram_round_trips_through_serde_and_keeps_integrity() {
let engram = fresh_engram(b"round-trip".to_vec());
let json = serde_json::to_string(&engram).unwrap();
let round: Engram = serde_json::from_str(&json).unwrap();
assert_eq!(round, engram);
round.verify_integrity().unwrap();
}
#[test]
fn engram_loads_with_default_version_when_field_missing() {
let payload = b"x".to_vec();
let hash = Hash::of(&payload);
let json = format!(
r#"{{
"schema": "{schema}",
"payload": [120],
"content_hash": "{hash}",
"privacy": "LocalOnly",
"provenance": {{
"origin": "Generated",
"generated_at": 0
}},
"trust": {{
"level": "SelfAsserted",
"moderation_state": "Unreviewed"
}},
"bounds": {{
"from": 0,
"to": 0
}}
}}"#,
schema = test_schema_ref().0.0.to_hex(),
hash = hash.to_hex(),
);
let engram: Engram = serde_json::from_str(&json).unwrap();
assert_eq!(engram.envelope_version, Engram::CURRENT_VERSION);
engram.verify_integrity().unwrap();
}
}