Enum Constraint 

pub enum Constraint {
    Known {
        known: KnownConstraint,
        extra: Map<String, Value>,
    },
    Unknown {
        constraint_type: String,
        fields: Map<String, Value>,
    },
}

A constraint carried by an L2 open mandate.

The constraint model is extensible: implementations define their own types, and the registered set grows over time, so a verifier will meet tags newer than itself. An unrecognized constraint is kept verbatim rather than failing the whole evaluation at parse time, so that a strictness policy can decide what it means. The specification requires that every field of such a constraint survive parsing.

Variants

Known

A constraint type this build can evaluate.

Fields

known: KnownConstraint

The recognized constraint.

extra: Map<String, Value>

Fields the recognized variant did not consume.

Preservation is required of every constraint object, not only of unrecognized types: a newer issuer may add a field to a type this build already knows, and a stage that reads the constraint later cannot recover what this parser discarded. The reference implementation carries the same thing on every constraint class.

Unknown

A constraint type this build does not recognize, preserved in full.

Fields

constraint_type: String

fields: Map<String, Value>

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Constraint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Constraint

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Eq for Constraint

impl From<KnownConstraint> for Constraint

fn from(known: KnownConstraint) -> Self

Wrap a recognized constraint that carries no additional fields.

This is a convenience over the recognized representation and asserts nothing about verification. The opaque verified types deliberately have no such conversion.

impl PartialEq for Constraint

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Emit the constraint, refusing any value whose serialized form is a different constraint from the one in hand.

The recognized value comes from the parser and the preserved fields come from the caller, so the two can disagree. There are four ways, and all of them are reachable only from a hand-built value, since the parser derives its preserved set from whatever the recognized value did not consume:

• a preserved field named after one the variant emits,
• a preserved type on the unrecognized arm,
• a preserved field named after one the variant omits, which skip_serializing_if keeps out of the emitted object entirely,
• an unrecognized constraint carrying a tag this build does recognize, whose bytes parse back as the recognized variant.

The first two are refused by name while the object is built. The last two are invisible to a name check, so the rule is applied to the result instead: parse the emitted bytes back and compare what a checker would read. Stating it once over the whole type is what keeps the next variation from having to be foreseen.

This matters because the issuance path is public and signs what it is handed. A mismatch here puts a constraint into a signed mandate that no checker ever evaluated, and the fourth case does so in the direction that fails open.

impl StructuralPartialEq for Constraint