Enum keri_controller::BasicPrefix

pub enum BasicPrefix {
    ECDSAsecp256k1NT(PublicKey),
    ECDSAsecp256k1(PublicKey),
    Ed25519NT(PublicKey),
    Ed25519(PublicKey),
    Ed448NT(PublicKey),
    Ed448(PublicKey),
    X25519(PublicKey),
    X448(PublicKey),
}

Variants

ECDSAsecp256k1NT(PublicKey)

ECDSAsecp256k1(PublicKey)

Ed25519NT(PublicKey)

Ed25519(PublicKey)

Ed448NT(PublicKey)

Ed448(PublicKey)

X25519(PublicKey)

X448(PublicKey)

Implementations

impl BasicPrefix

pub fn new(code: Basic, public_key: PublicKey) -> BasicPrefix

pub fn verify( &self, data: &[u8], signature: &SelfSigningPrefix, ) -> Result<bool, SignatureError>

pub fn is_transferable(&self) -> bool

Non transferable means that the public key is always the current public key. Transferable means that the public key might have changed and you need to request KEL to obtain the newest one.

pub fn get_code(&self) -> Basic

Trait Implementations

impl CesrPrimitive for BasicPrefix

fn derivative(&self) -> Vec<u8>

fn derivation_code(&self) -> PrimitiveCode

fn to_str(&self) -> String

impl Clone for BasicPrefix

fn clone(&self) -> BasicPrefix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BasicPrefix

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BasicPrefix

Serde compatible Deserialize

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(Basic, Vec<u8>)> for BasicPrefix

fn from(pk: (Basic, Vec<u8>)) -> BasicPrefix

Converts to this type from the input type.

impl FromStr for BasicPrefix

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<BasicPrefix, <BasicPrefix as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for BasicPrefix

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Into<(Basic, Vec<u8>)> for BasicPrefix

fn into(self) -> (Basic, Vec<u8>)

Converts this type into the (usually inferred) input type.

impl PartialEq for BasicPrefix

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

Serde compatible Serialize

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.

impl Eq for BasicPrefix

impl StructuralPartialEq for BasicPrefix