eros-nft 0.2.0

Reference implementation of the eros-nft v1 spec: types, validators, sample loader, and CLI for Solana persona NFT cards.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! JSON Schema 2020-12 validators backed by the embedded spec schemas.

use std::sync::OnceLock;

use jsonschema::Validator;
use serde_json::Value;

use crate::error::ValidationError;
use crate::schema::{json_schema_draft, json_schema_manifest};
use crate::types::{PersonaDraft, PersonaManifest};

fn draft_validator() -> &'static Validator {
    static V: OnceLock<Validator> = OnceLock::new();
    V.get_or_init(|| {
        let schema: Value =
            serde_json::from_str(json_schema_draft()).expect("embedded Draft schema is valid JSON");
        // The Manifest schema $refs into the Draft schema; for Draft alone we don't
        // need the Manifest doc, but we register it as a peer for symmetry.
        Validator::options()
            .with_draft(jsonschema::Draft::Draft202012)
            .build(&schema)
            .expect("embedded Draft schema is valid JSON Schema 2020-12")
    })
}

fn manifest_validator() -> &'static Validator {
    static V: OnceLock<Validator> = OnceLock::new();
    V.get_or_init(|| {
        let manifest_schema: Value = serde_json::from_str(json_schema_manifest())
            .expect("embedded Manifest schema is valid JSON");
        let draft_schema: Value =
            serde_json::from_str(json_schema_draft()).expect("embedded Draft schema is valid JSON");
        Validator::options()
            .with_draft(jsonschema::Draft::Draft202012)
            .with_resource(
                "https://eros.nft/spec/v1.0/persona-draft.schema.json",
                jsonschema::Resource::from_contents(draft_schema)
                    .expect("Draft schema is a valid Resource"),
            )
            .build(&manifest_schema)
            .expect("embedded Manifest schema is valid JSON Schema 2020-12")
    })
}

fn validate_with(validator: &Validator, json: &Value) -> Result<(), ValidationError> {
    if let Err(err) = validator.validate(json) {
        return Err(ValidationError::SchemaViolation {
            path: err.instance_path.to_string(),
            message: err.to_string(),
        });
    }
    Ok(())
}

impl PersonaDraft {
    /// Validate this `PersonaDraft` against the v1.0 JSON Schema and the
    /// spec's cross-field invariants.
    pub fn validate(&self) -> Result<(), ValidationError> {
        let json =
            serde_json::to_value(self).map_err(|e| ValidationError::InvalidJson(e.to_string()))?;
        validate_with(draft_validator(), &json)
    }
}

impl PersonaManifest {
    /// Validate this `PersonaManifest` against the v1.0 JSON Schema and the
    /// spec's cross-field invariants.
    pub fn validate(&self) -> Result<(), ValidationError> {
        let json =
            serde_json::to_value(self).map_err(|e| ValidationError::InvalidJson(e.to_string()))?;
        validate_with(manifest_validator(), &json)?;
        // Cross-field invariant: aad must equal persona_id.
        if self.prompt_ciphertext_ref.aad != self.persona_id {
            return Err(ValidationError::InvariantViolation(format!(
                "prompt_ciphertext_ref.aad ({}) must equal persona_id ({})",
                self.prompt_ciphertext_ref.aad, self.persona_id
            )));
        }
        Ok(())
    }
}