Skip to main content

proof_format/
schema.rs

1// Copyright 2026 Proof Engine Contributors
2// SPDX-License-Identifier: MIT OR Apache-2.0
3//! Closed schemas for Event / Attestation / Evidence / Relationship / Proof (FORMAT §4).
4//! Unknown fields and unknown enum variants are rejected (fail closed).
5
6use proof_core::{
7    model::{
8        AttestationContent, Claim, EventContent, EventType, Evidence, EvidenceKind, MetaValue,
9        Proof, Proposition, RelType, Relationship, StoredAttestation,
10    },
11    ErrorCode, HashAlgorithm, HashRef, Limits, ProofError,
12};
13
14use crate::cbor::CborValue;
15use std::collections::HashSet;
16
17fn text_field(map: &[(CborValue, CborValue)], key: &str) -> Result<String, ProofError> {
18    for (k, v) in map {
19        if let CborValue::Text(kk) = k {
20            if kk == key {
21                if let CborValue::Text(s) = v {
22                    if s.is_empty() || s.len() > 1024 {
23                        return Err(ErrorCode::SchemaViolation
24                            .err(format!("field {key} length out of bounds")));
25                    }
26                    return Ok(s.clone());
27                }
28                return Err(ErrorCode::SchemaViolation.err(format!("field {key} must be text")));
29            }
30        }
31    }
32    Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
33}
34
35fn uint_field(map: &[(CborValue, CborValue)], key: &str) -> Result<u64, ProofError> {
36    for (k, v) in map {
37        if let CborValue::Text(kk) = k {
38            if kk == key {
39                if let CborValue::Uint(n) = v {
40                    return Ok(*n);
41                }
42                return Err(ErrorCode::SchemaViolation.err(format!("field {key} must be uint")));
43            }
44        }
45    }
46    Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
47}
48
49fn opt_text_or_nil(
50    map: &[(CborValue, CborValue)],
51    key: &str,
52) -> Result<Option<String>, ProofError> {
53    for (k, v) in map {
54        if let CborValue::Text(kk) = k {
55            if kk == key {
56                match v {
57                    CborValue::Null => return Ok(None),
58                    CborValue::Text(s) => {
59                        if s.is_empty() || s.len() > 1024 {
60                            return Err(
61                                ErrorCode::SchemaViolation.err(format!("field {key} too long"))
62                            );
63                        }
64                        return Ok(Some(s.clone()));
65                    }
66                    _ => {
67                        return Err(
68                            ErrorCode::SchemaViolation.err(format!("field {key} must be text|nil"))
69                        )
70                    }
71                }
72            }
73        }
74    }
75    Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
76}
77
78fn opt_uint_or_nil(map: &[(CborValue, CborValue)], key: &str) -> Result<Option<u64>, ProofError> {
79    for (k, v) in map {
80        if let CborValue::Text(kk) = k {
81            if kk == key {
82                match v {
83                    CborValue::Null => return Ok(None),
84                    CborValue::Uint(n) => return Ok(Some(*n)),
85                    _ => {
86                        return Err(
87                            ErrorCode::SchemaViolation.err(format!("field {key} must be uint|nil"))
88                        )
89                    }
90                }
91            }
92        }
93    }
94    Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
95}
96
97fn check_version(map: &[(CborValue, CborValue)]) -> Result<(), ProofError> {
98    for (k, v) in map {
99        if let CborValue::Text(kk) = k {
100            if kk == "v" {
101                if let CborValue::Uint(1) = v {
102                    return Ok(());
103                }
104                return Err(ErrorCode::UnsupportedVersion.err("only v=1 supported"));
105            }
106        }
107    }
108    Err(ErrorCode::SchemaViolation.err("missing field v"))
109}
110
111// PE-FMT-008 (closed schemas/versions/enums).
112fn check_closed(
113    map: &[(CborValue, CborValue)],
114    allowed: &[&str],
115    what: &str,
116) -> Result<(), ProofError> {
117    for (k, _) in map {
118        if let CborValue::Text(kk) = k {
119            if !allowed.contains(&kk.as_str()) {
120                return Err(ErrorCode::SchemaViolation.err(format!("{what}: unknown field {kk}")));
121            }
122        } else {
123            return Err(ErrorCode::SchemaViolation.err(format!("{what}: non-text map key")));
124        }
125    }
126    Ok(())
127}
128
129fn meta_value_from_cbor(v: &CborValue) -> Result<MetaValue, ProofError> {
130    match v {
131        CborValue::Text(s) => {
132            if s.len() > 1024 {
133                return Err(ErrorCode::SchemaViolation.err("meta text too long"));
134            }
135            Ok(MetaValue::Text(s.clone()))
136        }
137        CborValue::Uint(n) => Ok(MetaValue::Uint(*n)),
138        CborValue::Bool(b) => Ok(MetaValue::Bool(*b)),
139        _ => Err(ErrorCode::SchemaViolation.err("meta value must be text|uint|bool")),
140    }
141}
142
143fn meta_value_to_cbor(m: &MetaValue) -> CborValue {
144    match m {
145        MetaValue::Text(s) => CborValue::Text(s.clone()),
146        MetaValue::Uint(n) => CborValue::Uint(*n),
147        MetaValue::Bool(b) => CborValue::Bool(*b),
148    }
149}
150
151fn hashref_to_cbor(h: &HashRef) -> CborValue {
152    CborValue::Map(vec![
153        (
154            CborValue::Text("alg".into()),
155            CborValue::Uint(h.alg.cbor_enum()),
156        ),
157        (
158            CborValue::Text("digest".into()),
159            CborValue::Bytes(h.digest.clone()),
160        ),
161        (CborValue::Text("v".into()), CborValue::Uint(h.v as u64)),
162    ])
163}
164
165fn hashref_from_cbor(v: &CborValue) -> Result<HashRef, ProofError> {
166    let map = match v {
167        CborValue::Map(p) => p,
168        _ => return Err(ErrorCode::SchemaViolation.err("payload_ref must be map")),
169    };
170    check_closed(map, &["v", "alg", "digest"], "HashRef")?;
171    check_version(map)?;
172    let alg_n = uint_field(map, "alg")?;
173    let alg = HashAlgorithm::from_cbor_enum(alg_n)?;
174    let digest = map
175        .iter()
176        .find_map(|(k, val)| match k {
177            CborValue::Text(kk) if kk == "digest" => match val {
178                CborValue::Bytes(b) => Some(b.clone()),
179                _ => None,
180            },
181            _ => None,
182        })
183        .ok_or_else(|| ErrorCode::SchemaViolation.err("HashRef.digest must be bytes"))?;
184    HashRef::new(alg, digest)
185}
186
187// ---------- Event ----------
188
189const EVENT_FIELDS: &[&str] = &[
190    "effective_at",
191    "metadata",
192    "payload_ref",
193    "subject",
194    "type",
195    "v",
196];
197
198/// Domain → canonical-model CBOR (maps are sorted at encode time).
199pub fn event_to_cbor(e: &EventContent) -> Result<CborValue, ProofError> {
200    // PE-FMT-008: version confusion fails closed as data, never panics.
201    if e.v != 1 {
202        return Err(ErrorCode::UnsupportedVersion.err("only v=1 encodable"));
203    }
204    let meta: Vec<(CborValue, CborValue)> = e
205        .metadata
206        .iter()
207        .map(|(k, v)| (CborValue::Text(k.clone()), meta_value_to_cbor(v)))
208        .collect();
209    Ok(CborValue::Map(vec![
210        (
211            CborValue::Text("effective_at".into()),
212            CborValue::Uint(e.effective_at),
213        ),
214        (CborValue::Text("metadata".into()), CborValue::Map(meta)),
215        (
216            CborValue::Text("payload_ref".into()),
217            hashref_to_cbor(&e.payload_ref),
218        ),
219        (
220            CborValue::Text("subject".into()),
221            CborValue::Text(e.subject.clone()),
222        ),
223        (
224            CborValue::Text("type".into()),
225            CborValue::Text(e.event_type.as_str().into()),
226        ),
227        (CborValue::Text("v".into()), CborValue::Uint(1)),
228    ]))
229}
230
231/// CBOR → domain with closed validation.
232pub fn cbor_to_event(v: &CborValue, limits: &Limits) -> Result<EventContent, ProofError> {
233    let map = match v {
234        CborValue::Map(p) => p,
235        _ => return Err(ErrorCode::SchemaViolation.err("Event must be map")),
236    };
237    if map.len() > limits.max_map_entries {
238        return Err(ErrorCode::LimitExceeded.err("Event map too large"));
239    }
240    check_closed(map, EVENT_FIELDS, "Event")?;
241    check_version(map)?;
242    let t = text_field(map, "type")?;
243    // V1.0 NEUTRAL: accept any string, policy decides which types are valid
244    let event_type = EventType::new(t);
245    let subject = text_field(map, "subject")?;
246    let effective_at = uint_field(map, "effective_at")?;
247    let pref = map
248        .iter()
249        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "payload_ref"))
250        .map(|(_, v)| v)
251        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field payload_ref"))?;
252    let payload_ref = hashref_from_cbor(pref)?;
253    let meta_cbor = map
254        .iter()
255        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "metadata"))
256        .map(|(_, v)| v)
257        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field metadata"))?;
258    let meta_pairs = match meta_cbor {
259        CborValue::Map(p) => p,
260        _ => return Err(ErrorCode::SchemaViolation.err("metadata must be map")),
261    };
262    if meta_pairs.len() > 16 {
263        return Err(ErrorCode::LimitExceeded.err("metadata too many entries"));
264    }
265    let mut seen = HashSet::new();
266    let mut metadata = Vec::with_capacity(meta_pairs.len());
267    for (k, val) in meta_pairs {
268        let ks = match k {
269            CborValue::Text(s) => s,
270            _ => return Err(ErrorCode::SchemaViolation.err("metadata key must be text")),
271        };
272        if ks.len() > 64 || !seen.insert(ks.clone()) {
273            return Err(ErrorCode::SchemaViolation.err("bad metadata key"));
274        }
275        metadata.push((ks.clone(), meta_value_from_cbor(val)?));
276    }
277    Ok(EventContent {
278        v: 1,
279        event_type,
280        subject,
281        effective_at,
282        payload_ref,
283        metadata,
284    })
285}
286
287// ---------- Attestation ----------
288
289const ATT_FIELDS: &[&str] = &[
290    "claim",
291    "evidence_ref",
292    "expires_at",
293    "issued_at",
294    "issuer",
295    "subject",
296    "v",
297];
298
299pub fn attestation_to_cbor(a: &AttestationContent) -> CborValue {
300    let mut claim_pairs = vec![(
301        CborValue::Text("type".into()),
302        CborValue::Text(a.claim.claim_type.clone()),
303    )];
304    for (k, v) in &a.claim.fields {
305        claim_pairs.push((CborValue::Text(k.clone()), meta_value_to_cbor(v)));
306    }
307    CborValue::Map(vec![
308        (CborValue::Text("claim".into()), CborValue::Map(claim_pairs)),
309        (
310            CborValue::Text("evidence_ref".into()),
311            match &a.evidence_ref {
312                Some(s) => CborValue::Text(s.clone()),
313                None => CborValue::Null,
314            },
315        ),
316        (
317            CborValue::Text("expires_at".into()),
318            match a.expires_at {
319                Some(n) => CborValue::Uint(n),
320                None => CborValue::Null,
321            },
322        ),
323        (
324            CborValue::Text("issued_at".into()),
325            CborValue::Uint(a.issued_at),
326        ),
327        (
328            CborValue::Text("issuer".into()),
329            CborValue::Text(a.issuer.clone()),
330        ),
331        (
332            CborValue::Text("subject".into()),
333            CborValue::Text(a.subject.clone()),
334        ),
335        (CborValue::Text("v".into()), CborValue::Uint(1)),
336    ])
337}
338
339pub fn cbor_to_attestation(
340    v: &CborValue,
341    limits: &Limits,
342) -> Result<AttestationContent, ProofError> {
343    let map = match v {
344        CborValue::Map(p) => p,
345        _ => return Err(ErrorCode::SchemaViolation.err("Attestation must be map")),
346    };
347    if map.len() > limits.max_map_entries {
348        return Err(ErrorCode::LimitExceeded.err("Attestation map too large"));
349    }
350    check_closed(map, ATT_FIELDS, "Attestation")?;
351    check_version(map)?;
352    let issuer = text_field(map, "issuer")?;
353    let subject = text_field(map, "subject")?;
354    let issued_at = uint_field(map, "issued_at")?;
355    let expires_at = opt_uint_or_nil(map, "expires_at")?;
356    let evidence_ref = opt_text_or_nil(map, "evidence_ref")?;
357    if let (Some(e), _) = (expires_at, issued_at) {
358        if e < issued_at {
359            return Err(ErrorCode::SchemaViolation.err("expires_at < issued_at"));
360        }
361    }
362    let claim_cbor = map
363        .iter()
364        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "claim"))
365        .map(|(_, v)| v)
366        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field claim"))?;
367    let claim_pairs = match claim_cbor {
368        CborValue::Map(p) => p,
369        _ => return Err(ErrorCode::SchemaViolation.err("claim must be map")),
370    };
371    if claim_pairs.len() > 16 || claim_pairs.is_empty() {
372        return Err(ErrorCode::SchemaViolation.err("claim size out of bounds"));
373    }
374    let mut claim_type: Option<String> = None;
375    let mut fields = Vec::new();
376    let mut seen = HashSet::new();
377    for (k, val) in claim_pairs {
378        let ks = match k {
379            CborValue::Text(s) => s,
380            _ => return Err(ErrorCode::SchemaViolation.err("claim key must be text")),
381        };
382        if !seen.insert(ks.clone()) {
383            return Err(ErrorCode::SchemaViolation.err("duplicate claim key"));
384        }
385        if ks == "type" {
386            match val {
387                CborValue::Text(s) => {
388                    if s.is_empty() || s.len() > 128 {
389                        return Err(ErrorCode::SchemaViolation.err("bad claim type"));
390                    }
391                    claim_type = Some(s.clone());
392                }
393                _ => return Err(ErrorCode::SchemaViolation.err("claim.type must be text")),
394            }
395        } else {
396            fields.push((ks.clone(), meta_value_from_cbor(val)?));
397        }
398    }
399    let claim_type =
400        claim_type.ok_or_else(|| ErrorCode::SchemaViolation.err("missing claim.type"))?;
401    void_limits(limits)?;
402    Ok(AttestationContent {
403        v: 1,
404        issuer,
405        subject,
406        claim: Claim { claim_type, fields },
407        issued_at,
408        expires_at,
409        evidence_ref,
410    })
411}
412
413// ---------- Evidence ----------
414
415const EVIDENCE_FIELDS: &[&str] = &["attestation_ref", "digest", "hint", "kind", "v"];
416
417pub fn evidence_to_cbor(e: &Evidence) -> CborValue {
418    CborValue::Map(vec![
419        (
420            CborValue::Text("attestation_ref".into()),
421            match &e.attestation_ref {
422                Some(s) => CborValue::Text(s.clone()),
423                None => CborValue::Null,
424            },
425        ),
426        (CborValue::Text("digest".into()), hashref_to_cbor(&e.digest)),
427        (
428            CborValue::Text("hint".into()),
429            match &e.hint {
430                Some(s) => CborValue::Text(s.clone()),
431                None => CborValue::Null,
432            },
433        ),
434        (
435            CborValue::Text("kind".into()),
436            CborValue::Text(e.kind.as_str().into()),
437        ),
438        (CborValue::Text("v".into()), CborValue::Uint(1)),
439    ])
440}
441
442pub fn cbor_to_evidence(v: &CborValue, limits: &Limits) -> Result<Evidence, ProofError> {
443    let map = match v {
444        CborValue::Map(p) => p,
445        _ => return Err(ErrorCode::SchemaViolation.err("Evidence must be map")),
446    };
447    if map.len() > limits.max_map_entries {
448        return Err(ErrorCode::LimitExceeded.err("Evidence map too large"));
449    }
450    check_closed(map, EVIDENCE_FIELDS, "Evidence")?;
451    check_version(map)?;
452    let k = text_field(map, "kind")?;
453    // V1.0 NEUTRAL: accept any string, policy decides which kinds are valid
454    let kind = EvidenceKind::new(k);
455    let digest_cbor = map
456        .iter()
457        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "digest"))
458        .map(|(_, v)| v)
459        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field digest"))?;
460    let digest = hashref_from_cbor(digest_cbor)?;
461    let attestation_ref = opt_text_or_nil(map, "attestation_ref")?;
462    let hint = opt_text_or_nil(map, "hint")?;
463    if hint.as_deref().is_some_and(|s| s.len() > 256) {
464        return Err(ErrorCode::SchemaViolation.err("hint too long"));
465    }
466    void_limits(limits)?;
467    Ok(Evidence {
468        v: 1,
469        kind,
470        digest,
471        attestation_ref,
472        hint,
473    })
474}
475
476fn void_limits(_: &Limits) -> Result<(), ProofError> {
477    Ok(())
478}
479
480// ---------- Relationship ----------
481
482const REL_FIELDS: &[&str] = &["attestation_ref", "evidence_ref", "from", "to", "type", "v"];
483
484pub fn relationship_to_cbor(r: &Relationship) -> CborValue {
485    CborValue::Map(vec![
486        (
487            CborValue::Text("attestation_ref".into()),
488            match &r.attestation_ref {
489                Some(s) => CborValue::Text(s.clone()),
490                None => CborValue::Null,
491            },
492        ),
493        (
494            CborValue::Text("evidence_ref".into()),
495            match &r.evidence_ref {
496                Some(s) => CborValue::Text(s.clone()),
497                None => CborValue::Null,
498            },
499        ),
500        (
501            CborValue::Text("from".into()),
502            CborValue::Text(r.from.clone()),
503        ),
504        (CborValue::Text("to".into()), CborValue::Text(r.to.clone())),
505        (
506            CborValue::Text("type".into()),
507            CborValue::Text(r.rel_type.as_str().into()),
508        ),
509        (CborValue::Text("v".into()), CborValue::Uint(1)),
510    ])
511}
512
513pub fn cbor_to_relationship(v: &CborValue, limits: &Limits) -> Result<Relationship, ProofError> {
514    let map = match v {
515        CborValue::Map(p) => p,
516        _ => return Err(ErrorCode::SchemaViolation.err("Relationship must be map")),
517    };
518    if map.len() > limits.max_map_entries {
519        return Err(ErrorCode::LimitExceeded.err("Relationship map too large"));
520    }
521    check_closed(map, REL_FIELDS, "Relationship")?;
522    check_version(map)?;
523    let from = text_field(map, "from")?;
524    let to = text_field(map, "to")?;
525    if from == to {
526        return Err(ErrorCode::SchemaViolation.err("self-edge forbidden in V0.1"));
527    }
528    let t = text_field(map, "type")?;
529    // V1.0 NEUTRAL: accept any string, policy decides which types are valid
530    let rel_type = RelType::new(t);
531    let evidence_ref = opt_text_or_nil(map, "evidence_ref")?;
532    let attestation_ref = opt_text_or_nil(map, "attestation_ref")?;
533    void_limits(limits)?;
534    Ok(Relationship {
535        v: 1,
536        from,
537        rel_type,
538        to,
539        evidence_ref,
540        attestation_ref,
541    })
542}
543
544// ---------- Proposition ----------
545
546const PROP_FIELDS: &[&str] = &[
547    "at_time",
548    "context",
549    "kind",
550    "object",
551    "predicate",
552    "subject",
553    "v",
554];
555
556pub fn proposition_to_cbor(p: &Proposition) -> CborValue {
557    let ctx: Vec<(CborValue, CborValue)> = p
558        .context
559        .iter()
560        .map(|(k, v)| (CborValue::Text(k.clone()), meta_value_to_cbor(v)))
561        .collect();
562    CborValue::Map(vec![
563        (
564            CborValue::Text("at_time".into()),
565            match p.at_time {
566                Some(n) => CborValue::Uint(n),
567                None => CborValue::Null,
568            },
569        ),
570        (CborValue::Text("context".into()), CborValue::Map(ctx)),
571        (
572            CborValue::Text("kind".into()),
573            CborValue::Text(p.kind.clone()),
574        ),
575        (
576            CborValue::Text("object".into()),
577            match &p.object {
578                Some(s) => CborValue::Text(s.clone()),
579                None => CborValue::Null,
580            },
581        ),
582        (
583            CborValue::Text("predicate".into()),
584            CborValue::Text(p.predicate.clone()),
585        ),
586        (
587            CborValue::Text("subject".into()),
588            CborValue::Text(p.subject.clone()),
589        ),
590        (CborValue::Text("v".into()), CborValue::Uint(1)),
591    ])
592}
593
594pub fn cbor_to_proposition(v: &CborValue, limits: &Limits) -> Result<Proposition, ProofError> {
595    let map = match v {
596        CborValue::Map(p) => p,
597        _ => return Err(ErrorCode::SchemaViolation.err("Proposition must be map")),
598    };
599    if map.len() > limits.max_map_entries {
600        return Err(ErrorCode::LimitExceeded.err("Proposition map too large"));
601    }
602    check_closed(map, PROP_FIELDS, "Proposition")?;
603    check_version(map)?;
604    let kind = text_field(map, "kind")?;
605    let subject = text_field(map, "subject")?;
606    let predicate = text_field(map, "predicate")?;
607    let object = opt_text_or_nil(map, "object")?;
608    let at_time = opt_uint_or_nil(map, "at_time")?;
609    let ctx_cbor = map
610        .iter()
611        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "context"))
612        .map(|(_, v)| v)
613        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field context"))?;
614    let ctx_pairs = match ctx_cbor {
615        CborValue::Map(p) => p,
616        _ => return Err(ErrorCode::SchemaViolation.err("context must be map")),
617    };
618    if ctx_pairs.len() > 16 {
619        return Err(ErrorCode::LimitExceeded.err("context too many entries"));
620    }
621    let mut seen = HashSet::new();
622    let mut context = Vec::with_capacity(ctx_pairs.len());
623    for (k, val) in ctx_pairs {
624        let ks = match k {
625            CborValue::Text(s) => s,
626            _ => return Err(ErrorCode::SchemaViolation.err("context key must be text")),
627        };
628        if ks.len() > 64 || !seen.insert(ks.clone()) {
629            return Err(ErrorCode::SchemaViolation.err("bad context key"));
630        }
631        context.push((ks.clone(), meta_value_from_cbor(val)?));
632    }
633    void_limits(limits)?;
634    Ok(Proposition {
635        v: 1,
636        kind,
637        subject,
638        predicate,
639        object,
640        at_time,
641        context,
642    })
643}
644
645// ---------- Proof ----------
646
647const PROOF_FIELDS: &[&str] = &[
648    "attestations",
649    "created_at",
650    "events",
651    "evidence",
652    "proof_id",
653    "proposition",
654    "relationships",
655    "v",
656];
657
658fn attestation_entry_to_cbor(a: &StoredAttestation) -> CborValue {
659    CborValue::Map(vec![
660        (
661            CborValue::Text("content".into()),
662            attestation_to_cbor(&a.content),
663        ),
664        (
665            CborValue::Text("sign1".into()),
666            CborValue::Bytes(a.sign1.clone()),
667        ),
668    ])
669}
670
671fn cbor_to_attestation_entry(
672    v: &CborValue,
673    limits: &Limits,
674) -> Result<StoredAttestation, ProofError> {
675    let map = match v {
676        CborValue::Map(p) => p,
677        _ => return Err(ErrorCode::SchemaViolation.err("attestation entry must be map")),
678    };
679    check_closed(map, &["content", "sign1"], "AttestationEntry")?;
680    let content_cbor = map
681        .iter()
682        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "content"))
683        .map(|(_, v)| v)
684        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field content"))?;
685    let content = cbor_to_attestation(content_cbor, limits)?;
686    let sign1 = map
687        .iter()
688        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "sign1"))
689        .map(|(_, v)| v)
690        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field sign1"))?;
691    let sign1 = match sign1 {
692        CborValue::Bytes(b) => {
693            if b.is_empty() || b.len() > limits.max_proof_size {
694                return Err(ErrorCode::LimitExceeded.err("sign1 size out of bounds"));
695            }
696            b.clone()
697        }
698        _ => return Err(ErrorCode::SchemaViolation.err("sign1 must be bytes")),
699    };
700    Ok(StoredAttestation { content, sign1 })
701}
702
703pub fn proof_to_cbor(p: &Proof) -> Result<CborValue, ProofError> {
704    let mut events = Vec::with_capacity(p.events.len());
705    for e in &p.events {
706        events.push(event_to_cbor(e)?);
707    }
708    Ok(CborValue::Map(vec![
709        (
710            CborValue::Text("attestations".into()),
711            CborValue::Array(
712                p.attestations
713                    .iter()
714                    .map(attestation_entry_to_cbor)
715                    .collect(),
716            ),
717        ),
718        (
719            CborValue::Text("created_at".into()),
720            CborValue::Uint(p.created_at),
721        ),
722        (CborValue::Text("events".into()), CborValue::Array(events)),
723        (
724            CborValue::Text("evidence".into()),
725            CborValue::Array(p.evidence.iter().map(evidence_to_cbor).collect()),
726        ),
727        (
728            CborValue::Text("proof_id".into()),
729            CborValue::Text(p.proof_id.clone()),
730        ),
731        (
732            CborValue::Text("proposition".into()),
733            proposition_to_cbor(&p.proposition),
734        ),
735        (
736            CborValue::Text("relationships".into()),
737            CborValue::Array(p.relationships.iter().map(relationship_to_cbor).collect()),
738        ),
739        (CborValue::Text("v".into()), CborValue::Uint(1)),
740    ]))
741}
742
743fn cbor_array<'a>(
744    map: &'a [(CborValue, CborValue)],
745    key: &str,
746) -> Result<&'a Vec<CborValue>, ProofError> {
747    map.iter()
748        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == key))
749        .map(|(_, v)| v)
750        .ok_or_else(|| ErrorCode::SchemaViolation.err(format!("missing field {key}")))
751        .and_then(|v| match v {
752            CborValue::Array(a) => Ok(a),
753            _ => Err(ErrorCode::SchemaViolation.err(format!("field {key} must be array"))),
754        })
755}
756
757/// Closed validation of the full Proof envelope (member bytes are NOT
758/// cryptographically verified here — that is the pipeline's job).
759pub fn cbor_to_proof(v: &CborValue, limits: &Limits) -> Result<Proof, ProofError> {
760    let map = match v {
761        CborValue::Map(p) => p,
762        _ => return Err(ErrorCode::SchemaViolation.err("Proof must be map")),
763    };
764    check_closed(map, PROOF_FIELDS, "Proof")?;
765    check_version(map)?;
766    let proof_id = text_field(map, "proof_id")?;
767    if !proof_id.starts_with("prf:v1:") {
768        return Err(ErrorCode::SchemaViolation.err("proof_id must start with prf:v1:"));
769    }
770    let prop_cbor = map
771        .iter()
772        .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "proposition"))
773        .map(|(_, v)| v)
774        .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field proposition"))?;
775    let proposition = cbor_to_proposition(prop_cbor, limits)?;
776    let created_at = uint_field(map, "created_at")?;
777
778    let mut events = vec![];
779    for item in cbor_array(map, "events")? {
780        events.push(cbor_to_event(item, limits)?);
781    }
782    let mut attestations = vec![];
783    for item in cbor_array(map, "attestations")? {
784        attestations.push(cbor_to_attestation_entry(item, limits)?);
785    }
786    let mut evidence = vec![];
787    for item in cbor_array(map, "evidence")? {
788        evidence.push(cbor_to_evidence(item, limits)?);
789    }
790    let mut relationships = vec![];
791    for item in cbor_array(map, "relationships")? {
792        relationships.push(cbor_to_relationship(item, limits)?);
793    }
794    // Semantic size bounds (decoder already caps raw array lengths).
795    if relationships.len() > limits.max_edges {
796        return Err(ErrorCode::LimitExceeded.err("too many relationships"));
797    }
798    if events.len() + attestations.len() + evidence.len() > limits.max_nodes {
799        return Err(ErrorCode::LimitExceeded.err("too many artifact members"));
800    }
801    void_limits(limits)?;
802    Ok(Proof {
803        v: 1,
804        proof_id,
805        proposition,
806        events,
807        attestations,
808        evidence,
809        relationships,
810        created_at,
811    })
812}
813
814#[cfg(test)]
815mod tests {
816    use super::*;
817    use proof_core::model::{Claim, EventType, EvidenceKind, MetaValue, RelType, Relationship};
818
819    pub fn event_fixture() -> EventContent {
820        EventContent {
821            v: 1,
822            event_type: EventType::new(EventType::PAYMENT_CREATED),
823            subject: "acct:merchant-01".into(),
824            effective_at: 1_700_000_000,
825            payload_ref: HashRef::new(HashAlgorithm::Sha256, vec![0xABu8; 32]).unwrap(),
826            metadata: vec![("order".into(), MetaValue::Text("ord-1".into()))],
827        }
828    }
829
830    /// PE-FMT-008: version confusion fails closed as data, never panics —
831    /// a hand-built v=2 event cannot be encoded (decode path already
832    /// rejects v!=1 with UNSUPPORTED_VERSION).
833    #[test]
834    fn event_v2_refuses_to_encode() {
835        let mut e = event_fixture();
836        e.v = 2;
837        let err = event_to_cbor(&e).unwrap_err();
838        assert_eq!(err.code, ErrorCode::UnsupportedVersion);
839    }
840
841    /// Shared fixture constructor lives in a tiny helper to keep vectors identical
842    /// between unit tests and the golden-vector generator.
843    #[test]
844    fn event_round_trip() {
845        let lim = Limits::default();
846        let e = event_fixture();
847        let v = event_to_cbor(&e).unwrap();
848        let bytes = crate::encode_canonical(&v);
849        let back = crate::decode_strict(&bytes, &lim).unwrap();
850        // Decoded pair order is canonical (sorted); re-encoding must be stable.
851        assert_eq!(crate::encode_canonical(&back), bytes);
852        let e2 = cbor_to_event(&back, &lim).unwrap();
853        assert_eq!(e2, e);
854    }
855
856    #[test]
857    fn unknown_event_type_accepted() {
858        // V1.0 NEUTRAL: unknown types are accepted, policy decides validity
859        let lim = Limits::default();
860        let v = CborValue::Map(vec![
861            (CborValue::Text("effective_at".into()), CborValue::Uint(1)),
862            (CborValue::Text("metadata".into()), CborValue::Map(vec![])),
863            (
864                CborValue::Text("payload_ref".into()),
865                CborValue::Map(vec![
866                    (CborValue::Text("alg".into()), CborValue::Uint(0)),
867                    (
868                        CborValue::Text("digest".into()),
869                        CborValue::Bytes(vec![0u8; 32]),
870                    ),
871                    (CborValue::Text("v".into()), CborValue::Uint(1)),
872                ]),
873            ),
874            (
875                CborValue::Text("subject".into()),
876                CborValue::Text("s".into()),
877            ),
878            (
879                CborValue::Text("type".into()),
880                CborValue::Text("healthcare.patient.admitted".into()),
881            ),
882            (CborValue::Text("v".into()), CborValue::Uint(1)),
883        ]);
884        let evt = cbor_to_event(&v, &lim).unwrap();
885        assert_eq!(evt.event_type.as_str(), "healthcare.patient.admitted");
886        assert!(!evt.event_type.is_well_known());
887    }
888
889    #[test]
890    fn unknown_field_rejected() {
891        let lim = Limits::default();
892        let mut e = event_fixture();
893        e.subject = "s".into();
894        let mut v = event_to_cbor(&e).unwrap();
895        if let CborValue::Map(p) = &mut v {
896            p.push((CborValue::Text("evil".into()), CborValue::Uint(1)));
897        }
898        assert_eq!(
899            cbor_to_event(&v, &lim).unwrap_err().code,
900            ErrorCode::SchemaViolation
901        );
902    }
903
904    #[test]
905    fn attestation_expires_before_issued_rejected() {
906        let lim = Limits::default();
907        let a = AttestationContent {
908            v: 1,
909            issuer: "key:ed25519:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
910            subject: "s".into(),
911            claim: Claim {
912                claim_type: "t".into(),
913                fields: vec![],
914            },
915            issued_at: 200,
916            expires_at: Some(100),
917            evidence_ref: None,
918        };
919        let v = attestation_to_cbor(&a);
920        assert_eq!(
921            cbor_to_attestation(&v, &lim).unwrap_err().code,
922            ErrorCode::SchemaViolation
923        );
924    }
925
926    #[test]
927    fn metadata_value_types_restricted() {
928        let lim = Limits::default();
929        let v = CborValue::Map(vec![
930            (CborValue::Text("effective_at".into()), CborValue::Uint(1)),
931            (
932                CborValue::Text("metadata".into()),
933                CborValue::Map(vec![(
934                    CborValue::Text("k".into()),
935                    CborValue::Array(vec![]),
936                )]),
937            ),
938            (
939                CborValue::Text("payload_ref".into()),
940                CborValue::Map(vec![
941                    (CborValue::Text("alg".into()), CborValue::Uint(0)),
942                    (
943                        CborValue::Text("digest".into()),
944                        CborValue::Bytes(vec![0u8; 32]),
945                    ),
946                    (CborValue::Text("v".into()), CborValue::Uint(1)),
947                ]),
948            ),
949            (
950                CborValue::Text("subject".into()),
951                CborValue::Text("s".into()),
952            ),
953            (
954                CborValue::Text("type".into()),
955                CborValue::Text("payment.created".into()),
956            ),
957            (CborValue::Text("v".into()), CborValue::Uint(1)),
958        ]);
959        assert_eq!(
960            cbor_to_event(&v, &lim).unwrap_err().code,
961            ErrorCode::SchemaViolation
962        );
963    }
964
965    #[test]
966    fn evidence_round_trip() {
967        let lim = Limits::default();
968        let e = Evidence {
969            v: 1,
970            kind: EvidenceKind::new(EvidenceKind::TRANSACTION_RECORD),
971            digest: HashRef::new(HashAlgorithm::Sha256, vec![0xCDu8; 32]).unwrap(),
972            attestation_ref: Some("att:v1:placeholder".into()),
973            hint: Some("invoice-I-9 settlement".into()),
974        };
975        let v = evidence_to_cbor(&e);
976        let bytes = crate::encode_canonical(&v);
977        let back = crate::decode_strict(&bytes, &lim).unwrap();
978        assert_eq!(crate::encode_canonical(&back), bytes);
979        assert_eq!(cbor_to_evidence(&back, &lim).unwrap(), e);
980    }
981
982    #[test]
983    fn unknown_evidence_kind_accepted() {
984        // V1.0 NEUTRAL: unknown kinds are accepted, policy decides validity
985        let lim = Limits::default();
986        let v = CborValue::Map(vec![
987            (CborValue::Text("attestation_ref".into()), CborValue::Null),
988            (
989                CborValue::Text("digest".into()),
990                CborValue::Map(vec![
991                    (CborValue::Text("alg".into()), CborValue::Uint(0)),
992                    (
993                        CborValue::Text("digest".into()),
994                        CborValue::Bytes(vec![0u8; 32]),
995                    ),
996                    (CborValue::Text("v".into()), CborValue::Uint(1)),
997                ]),
998            ),
999            (CborValue::Text("hint".into()), CborValue::Null),
1000            (
1001                CborValue::Text("kind".into()),
1002                CborValue::Text("medical_imaging".into()),
1003            ),
1004            (CborValue::Text("v".into()), CborValue::Uint(1)),
1005        ]);
1006        let evd = cbor_to_evidence(&v, &lim).unwrap();
1007        assert_eq!(evd.kind.as_str(), "medical_imaging");
1008        assert!(!evd.kind.is_well_known());
1009    }
1010
1011    #[test]
1012    fn relationship_round_trip() {
1013        let lim = Limits::default();
1014        let r = Relationship {
1015            v: 1,
1016            from: "evt:v1:aaa".into(),
1017            rel_type: RelType::new(RelType::SETTLES),
1018            to: "evt:v1:bbb".into(),
1019            evidence_ref: Some("evd:v1:ccc".into()),
1020            attestation_ref: None,
1021        };
1022        let v = relationship_to_cbor(&r);
1023        let bytes = crate::encode_canonical(&v);
1024        let back = crate::decode_strict(&bytes, &lim).unwrap();
1025        assert_eq!(crate::encode_canonical(&back), bytes);
1026        assert_eq!(cbor_to_relationship(&back, &lim).unwrap(), r);
1027    }
1028
1029    #[test]
1030    fn relationship_rejects_self_edge_and_accepts_unknown_type() {
1031        let lim = Limits::default();
1032        let base = Relationship {
1033            v: 1,
1034            from: "evt:v1:aaa".into(),
1035            rel_type: RelType::new(RelType::REFERENCES),
1036            to: "evt:v1:bbb".into(),
1037            evidence_ref: None,
1038            attestation_ref: None,
1039        };
1040        // V1.0 NEUTRAL: Unknown type is accepted, policy decides validity
1041        let mut v = relationship_to_cbor(&base);
1042        if let CborValue::Map(p) = &mut v {
1043            for (k, val) in p.iter_mut() {
1044                if matches!(k, CborValue::Text(s) if s == "type") {
1045                    *val = CborValue::Text("CUSTOM_RELATIONSHIP".into());
1046                }
1047            }
1048        }
1049        let rel = cbor_to_relationship(&v, &lim).unwrap();
1050        assert_eq!(rel.rel_type.as_str(), "CUSTOM_RELATIONSHIP");
1051        assert!(!rel.rel_type.is_well_known());
1052
1053        // Self-edge still rejected (V1 semantic rule)
1054        let mut selfy = base.clone();
1055        selfy.to = selfy.from.clone();
1056        let v2 = relationship_to_cbor(&selfy);
1057        assert_eq!(
1058            cbor_to_relationship(&v2, &lim).unwrap_err().code,
1059            ErrorCode::SchemaViolation
1060        );
1061    }
1062
1063    #[test]
1064    fn proposition_round_trip() {
1065        use proof_core::model::Proposition;
1066        let lim = Limits::default();
1067        let p = Proposition {
1068            v: 1,
1069            kind: "payment.settles-invoice".into(),
1070            subject: "payment:p9".into(),
1071            predicate: "settles".into(),
1072            object: Some("invoice:i9".into()),
1073            at_time: Some(1_700_000_000),
1074            context: vec![(
1075                "policy".into(),
1076                MetaValue::Text("merchant_payment_v1".into()),
1077            )],
1078        };
1079        let v = proposition_to_cbor(&p);
1080        let bytes = crate::encode_canonical(&v);
1081        let back = crate::decode_strict(&bytes, &lim).unwrap();
1082        assert_eq!(crate::encode_canonical(&back), bytes);
1083        assert_eq!(cbor_to_proposition(&back, &lim).unwrap(), p);
1084    }
1085
1086    #[test]
1087    fn proof_envelope_round_trip_and_bounds() {
1088        use proof_core::model::{AttestationContent, Claim, Proof, StoredAttestation};
1089        let lim = Limits::default();
1090        let p = Proof {
1091            v: 1,
1092            proof_id: "prf:v1:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
1093            proposition: Proposition {
1094                v: 1,
1095                kind: "k".into(),
1096                subject: "s".into(),
1097                predicate: "p".into(),
1098                object: None,
1099                at_time: None,
1100                context: vec![],
1101            },
1102            events: vec![],
1103            attestations: vec![StoredAttestation {
1104                content: AttestationContent {
1105                    v: 1,
1106                    issuer: "key:ed25519:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
1107                    subject: "s".into(),
1108                    claim: Claim {
1109                        claim_type: "t".into(),
1110                        fields: vec![],
1111                    },
1112                    issued_at: 1,
1113                    expires_at: None,
1114                    evidence_ref: None,
1115                },
1116                sign1: vec![0u8; 64],
1117            }],
1118            evidence: vec![],
1119            relationships: vec![],
1120            created_at: 1_700_000_000,
1121        };
1122        let v = proof_to_cbor(&p).unwrap();
1123        let bytes = crate::encode_canonical(&v);
1124        let back = crate::decode_strict(&bytes, &lim).unwrap();
1125        assert_eq!(crate::encode_canonical(&back), bytes);
1126        assert_eq!(cbor_to_proof(&back, &lim).unwrap(), p);
1127        // Bad proof_id prefix rejected at schema level.
1128        let mut bad = p.clone();
1129        bad.proof_id = "evt:v1:xxx".into();
1130        let vb = proof_to_cbor(&bad).unwrap();
1131        assert_eq!(
1132            cbor_to_proof(&vb, &lim).unwrap_err().code,
1133            ErrorCode::SchemaViolation
1134        );
1135    }
1136}