Struct sp_core::crypto::Dummy

pub struct Dummy;

Dummy cryptography. Doesn't do anything.

Trait Implementations

impl AsMut<[u8]> for Dummy

pub fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl AsRef<[u8]> for Dummy

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

Performs the conversion.

impl Clone for Dummy

pub fn clone(&self) -> Dummy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CryptoType for Dummy

type Pair = Dummy

The pair key type of this crypto.

impl Default for Dummy

pub fn default() -> Dummy

Returns the "default value" for a type.

impl Derive for Dummy

pub fn derive<Iter: Iterator<Item = DeriveJunction>>(
    &self,
    _path: Iter
) -> Option<Self>

Derive a child key from a series of given junctions.

impl Eq for Dummy

impl Hash for Dummy

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Pair for Dummy

type Public = Dummy

The type which is used to encode a public key.

type Seed = Dummy

The type used to (minimally) encode the data required to securely create a new key pair.

type Signature = Dummy

The type used to represent a signature. Can be created from a key pair and a message and verified with the message and a public key.

type DeriveError = ()

Error returned from the derive function.

pub fn generate_with_phrase(_: Option<&str>) -> (Self, String, Self::Seed)

Generate new secure (random) key pair and provide the recovery phrase.

pub fn from_phrase(
    _: &str,
    _: Option<&str>
) -> Result<(Self, Self::Seed), SecretStringError>

Returns the KeyPair from the English BIP39 seed phrase, or None if it's invalid.

pub fn derive<Iter: Iterator<Item = DeriveJunction>>(
    &self,
    _: Iter,
    _: Option<Dummy>
) -> Result<(Self, Option<Dummy>), Self::DeriveError>

Derive a child key from a series of given junctions.

pub fn from_seed(_: &Self::Seed) -> Self

Generate new key pair from the provided seed.

pub fn from_seed_slice(_: &[u8]) -> Result<Self, SecretStringError>

Make a new key pair from secret seed material. The slice must be the correct size or it will return None.

pub fn sign(&self, _: &[u8]) -> Self::Signature

Sign a message.

pub fn verify<M: AsRef<[u8]>>(
    _: &Self::Signature,
    _: M,
    _: &Self::Public
) -> bool

Verify a signature on a message. Returns true if the signature is good.

pub fn verify_weak<P: AsRef<[u8]>, M: AsRef<[u8]>>(_: &[u8], _: M, _: P) -> bool

Verify a signature on a message. Returns true if the signature is good.

pub fn public(&self) -> Self::Public

Get the public key.

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

Return a vec filled with raw data.

pub fn generate() -> (Self, Self::Seed)

Generate new secure (random) key pair.

pub fn from_string_with_seed(
    s: &str,
    password_override: Option<&str>
) -> Result<(Self, Option<Self::Seed>), SecretStringError>

Interprets the string s in order to generate a key Pair. Returns both the pair and an optional seed, in the case that the pair can be expressed as a direct derivation from a seed (some cases, such as Sr25519 derivations with path components, cannot).

pub fn from_string(
    s: &str,
    password_override: Option<&str>
) -> Result<Self, SecretStringError>

Interprets the string s in order to generate a key pair.

impl PartialEq<Dummy> for Dummy

pub fn eq(&self, other: &Dummy) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Public for Dummy

pub fn from_slice(_: &[u8]) -> Self

A new instance from the given slice.

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

Return a Vec<u8> filled with raw data.

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

Return a slice filled with raw data.

pub fn to_public_crypto_pair(&self) -> CryptoTypePublicPair

Return CryptoTypePublicPair from public key.

impl StructuralEq for Dummy

impl StructuralPartialEq for Dummy