Enum 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 Archive for BasicPrefix

where PublicKey: Archive,

type Archived = ArchivedBasicPrefix

The archived representation of this type.

type Resolver = BasicPrefixResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <BasicPrefix as Archive>::Resolver, out: Place<<BasicPrefix as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

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<__D> Deserialize<BasicPrefix, __D> for <BasicPrefix as Archive>::Archived

where __D: Fallible + ?Sized, PublicKey: Archive, <PublicKey as Archive>::Archived: Deserialize<PublicKey, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BasicPrefix, <__D as Fallible>::Error>

Deserializes using the given 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<ArchivedBasicPrefix> for BasicPrefix

where PublicKey: Archive, <PublicKey as Archive>::Archived: PartialEq<PublicKey>,

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

where __S: Fallible + ?Sized, PublicKey: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<BasicPrefix as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

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