Enum Signature 

#[non_exhaustive]
pub enum Signature {
    Ed25519 {
        signature: Ed25519Signature,
        public_key: Ed25519PublicKey,
    },
    Secp256k1 {
        signature: Secp256k1Signature,
        public_key: Secp256k1PublicKey,
    },
    Secp256r1 {
        signature: Secp256r1Signature,
        public_key: Secp256r1PublicKey,
    },
}

A basic signature

This enumeration defines the set of simple or basic signature schemes supported by IOTA. Most signature schemes supported by IOTA end up comprising of at least one simple signature scheme.

BCS

The BCS serialized form for this type is defined by the following ABNF:

simple-signature-bcs = bytes ; where the contents of the bytes are defined by <simple-signature>
simple-signature = (ed25519-flag ed25519-signature ed25519-public-key) /
                   (secp256k1-flag secp256k1-signature secp256k1-public-key) /
                   (secp256r1-flag secp256r1-signature secp256r1-public-key)

Note: Due to historical reasons, signatures are serialized slightly different from the majority of the types in IOTA. In particular if a signature is ever embedded in another structure it generally is serialized as bytes meaning it has a length prefix that defines the length of the completely serialized signature.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Ed25519

Fields

signature: Ed25519Signature

public_key: Ed25519PublicKey

Secp256k1

Fields

signature: Secp256k1Signature

public_key: Secp256k1PublicKey

Secp256r1

Fields

signature: Secp256r1Signature

public_key: Secp256r1PublicKey

Implementations

impl SimpleSignature

pub fn new_ed25519( signature: Ed25519Signature, public_key: Ed25519PublicKey, ) -> SimpleSignature

pub fn new_secp256k1( signature: Secp256k1Signature, public_key: Secp256k1PublicKey, ) -> SimpleSignature

pub fn new_secp256r1( signature: Secp256r1Signature, public_key: Secp256r1PublicKey, ) -> SimpleSignature

pub fn is_ed25519(&self) -> bool

Checks if this is a ed25519 variant.

pub fn is_secp256k1(&self) -> bool

Checks if this is a secp256k1 variant.

pub fn is_secp256r1(&self) -> bool

Checks if this is a secp256r1 variant.

pub fn as_ed25519_sig_opt(&self) -> Option<&Ed25519Signature>

pub fn as_ed25519_sig(&self) -> &Ed25519Signature

pub fn as_ed25519_pub_key_opt(&self) -> Option<&Ed25519PublicKey>

pub fn as_ed25519_pub_key(&self) -> &Ed25519PublicKey

pub fn into_ed25519_opt(self) -> Option<(Ed25519Signature, Ed25519PublicKey)>

pub fn into_ed25519(self) -> (Ed25519Signature, Ed25519PublicKey)

pub fn as_secp256k1_sig_opt(&self) -> Option<&Secp256k1Signature>

pub fn as_secp256k1_sig(&self) -> &Secp256k1Signature

pub fn as_secp256k1_pub_key_opt(&self) -> Option<&Secp256k1PublicKey>

pub fn as_secp256k1_pub_key(&self) -> &Secp256k1PublicKey

pub fn into_secp256k1_opt( self, ) -> Option<(Secp256k1Signature, Secp256k1PublicKey)>

pub fn into_secp256k1(self) -> (Secp256k1Signature, Secp256k1PublicKey)

pub fn as_secp256r1_sig_opt(&self) -> Option<&Secp256r1Signature>

pub fn as_secp256r1_sig(&self) -> &Secp256r1Signature

pub fn as_secp256r1_pub_key_opt(&self) -> Option<&Secp256r1PublicKey>

pub fn as_secp256r1_pub_key(&self) -> &Secp256r1PublicKey

pub fn into_secp256r1_opt( self, ) -> Option<(Secp256r1Signature, Secp256r1PublicKey)>

pub fn into_secp256r1(self) -> (Secp256r1Signature, Secp256r1PublicKey)

pub fn scheme(&self) -> SignatureScheme

Return the flag for this signature scheme

pub fn signature_bytes(&self) -> &[u8]

The raw signature bytes, without the scheme flag or the public key.

pub fn to_public_key(&self) -> PublicKey

The public key embedded in this signature.

The raw public-key bytes are available via AsRef on the returned [PublicKey].

impl SimpleSignature

pub fn to_bytes(&self) -> Vec<u8>

pub fn from_bytes( bytes: impl AsRef<[u8]>, ) -> Result<SimpleSignature, SignatureFromBytesError>

pub fn to_base64(&self) -> String

Base64-encode this signature as its flag || sig || pubkey bytes, the same layout as to_bytes.

pub fn from_base64(s: &str) -> Result<SimpleSignature, Error>

Decode a signature from the Base64 form produced by to_base64, i.e. base64 over the flag || sig || pubkey bytes.

Trait Implementations

impl Arbitrary for SimpleSignature

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<SimpleSignature>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( args_shared: <SimpleSignature as Arbitrary>::Parameters, ) -> <SimpleSignature as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl AuthenticatorTrait for Signature

This ports the wrapper trait to the verify_secure defined on crate::crypto::Signature.

fn verify_claims<T>( &self, value: &IntentMessage<T>, author: Address, _aux_verify_data: &VerifyParams, ) -> IotaResult

where T: Serialize,

impl Clone for SimpleSignature

fn clone(&self) -> SimpleSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleSignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SimpleSignature

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SimpleSignature> for MultisigMemberSignature

fn from(signature: SimpleSignature) -> MultisigMemberSignature

Converts to this type from the input type.

impl Hash for SimpleSignature

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 IotaSignature for Signature

fn verify_secure<T>( &self, value: &IntentMessage<T>, author: Address, ) -> Result<(), IotaError>

where T: Serialize,

fn new_hashed(hashed_msg: &[u8], secret: impl Into<IotaKeyPair>) -> Signature

Signs a message that is already in hashed form.

fn new_secure<T>( value: &IntentMessage<T>, secret: impl Into<IotaKeyPair>, ) -> Signature

where T: Serialize,

Signs the BCS hash of the value wrapped in the intent message.

impl PartialEq for SimpleSignature

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

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 Signer<SimpleSignature> for IotaKeyPair

fn sign(&self, msg: &[u8]) -> Signature

Create a new signature over a message.

impl Eq for SimpleSignature

impl StructuralPartialEq for SimpleSignature