Struct Valid 

pub struct Valid<T>(/* private fields */);

Validated value

Valid<T> wraps a value T that has been validated using Validate trait.

Valid<T> provides only immutable access to T. For instance, if you want to change content of T, you need to deconstruct it, do necessary modifications, and then validate it again.

Transitive “valideness” through AsRef

Valid<T> assumes that if T implements AsRef<K> and K can be validated (i.e. K implements Validate), then K has been validated when T was validated. Thus, if you have value of type Valid<T>, you can obtain &Valid<K> via AsRef trait.

Example of transitive valideness is demostrated below:

use key_share::{Validate, Valid};

pub type CoreKeyShare = Valid<DirtyCoreKeyShare>;
pub type KeyInfo = Valid<DirtyKeyInfo>;

pub struct DirtyCoreKeyShare {
    i: u16,
    key_info: DirtyKeyInfo,
    x: SecretScalar,
}
pub struct DirtyKeyInfo { /* ... */ }

// Key info can be validated separately
impl Validate for DirtyKeyInfo {
    type Error = InvalidKeyShare;
    fn is_valid(&self) -> Result<(), Self::Error> {
        // ...
    }
}

// CoreKeyShare can be validated as well
impl Validate for DirtyCoreKeyShare {
    type Error = InvalidKeyShare;
    fn is_valid(&self) -> Result<(), Self::Error> {
        // Since `key_info` is part of key share, it **must be** validated when
        // the key share is validated
        self.key_info.is_valid();
        // ...
    }
}
impl AsRef<DirtyKeyInfo> for DirtyCoreKeyShare {
    fn as_ref(&self) -> &DirtyKeyInfo {
        &self.key_info
    }
}

let key_share: CoreKeyShare = DirtyCoreKeyShare { i, key_info, x }.validate()?;

// Since `key_share` is validated, and it contains `key_info`, we can obtain a `&KeyInfo`.
// `Valid<T>` trusts that `<DirtyCoreKeyShare as Validate>::is_valid` has validated `key_info`.
let key_info: &KeyInfo = key_share.as_ref();

This mechanism allow to improve performance by not validating what’s already been validated. However, incorrect implementation of Validate trait may lead to obtaining Valid<K> that’s actually invalid. It may, in return, lead to runtime panic and/or compromised security of the application. Make sure that all implementations of Validate trait are correct and aligned with AsRef implementations.

Implementations

impl<T> Valid<T>

where T: Validate,

pub fn validate( value: T, ) -> Result<Valid<T>, ValidateError<T, <T as Validate>::Error>>

Validates the value

If value is valid, returns Ok(validated_value) wrapped into type guard Valid<T>, otherwise returns Err(err) containing the error and the invalid value.

pub fn validate_ref( value: &T, ) -> Result<&Valid<T>, ValidateError<&T, <T as Validate>::Error>>

Validates a reference to value &T returning &Valid<T> if it’s valid

pub fn from_parts<Parts>( parts: Parts, ) -> Result<Valid<T>, ValidateError<Parts, <T as Validate>::Error>>

where T: ValidateFromParts<Parts>,

Constructs and validates value from parts

Refer to ValidateFromParts trait documentation

impl<T> Valid<T>

pub fn into_inner(self) -> T

Returns wraped validated value

impl<E> Valid<DirtyCoreKeyShare<E>>

where E: Curve,

pub fn n(&self) -> u16

Returns amount of key co-holders

pub fn min_signers(&self) -> u16

Returns threshold

Threshold is an amount of signers required to cooperate in order to sign a message and/or generate presignature

pub fn shared_public_key(&self) -> NonZero<Point<E>>

Returns public key shared by signers

Trait Implementations

impl<T> AsRef<T> for Valid<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<E> AsRef<Valid<DirtyCoreKeyShare<E>>> for Valid<DirtyCoreKeyShare<E>>

where E: Curve,

fn as_ref(&self) -> &Valid<DirtyCoreKeyShare<E>>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, K> AsRef<Valid<K>> for Valid<T>

where T: Validate + AsRef<K>, K: Validate,

fn as_ref(&self) -> &Valid<K>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Valid<T>

where T: Clone,

fn clone(&self) -> Valid<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Valid<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Valid<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Valid<T> as Deref>::Target

Dereferences the value.

impl<'de, T> Deserialize<'de> for Valid<T>

where T: Validate + Deserialize<'de>, <T as Validate>::Error: Display,

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Valid<T>

where T: Serialize,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.