Trait hotshot::types::SignatureKey

pub trait SignatureKey:
    Sized
    + Send
    + Sync
    + Clone
    + Debug
    + Hash
    + Serialize
    + for<'a> Deserialize<'a>
    + PartialEq
    + Eq
    + PartialOrd
    + Ord
    + Display
    + for<'a> TryFrom<&'a TaggedBase64>
    + Into<TaggedBase64> {
    type PrivateKey: PrivateSignatureKey;
    type StakeTableEntry: StakeTableEntryType<Self> + Send + Sync + Clone + Debug + Hash + Eq + Serialize + for<'a> Deserialize<'a>;
    type QcParams: Send + Sync + Clone + Debug + Hash;
    type PureAssembledSignatureType: Send + Sync + Clone + Debug + Hash + PartialEq + Eq + Serialize + for<'a> Deserialize<'a> + Into<TaggedBase64> + for<'a> TryFrom<&'a TaggedBase64>;
    type QcType: Send + Sync + Clone + Debug + Hash + PartialEq + Eq + Serialize + for<'a> Deserialize<'a>;
    type SignError: Error + Send + Sync;

    // Required methods
    fn validate(
        &self,
        signature: &Self::PureAssembledSignatureType,
        data: &[u8],
    ) -> bool;
    fn sign(
        private_key: &Self::PrivateKey,
        data: &[u8],
    ) -> Result<Self::PureAssembledSignatureType, Self::SignError>;
    fn from_private(private_key: &Self::PrivateKey) -> Self;
    fn to_bytes(&self) -> Vec<u8> ;
    fn from_bytes(bytes: &[u8]) -> Result<Self, SerializationError>;
    fn generated_from_seed_indexed(
        seed: [u8; 32],
        index: u64,
    ) -> (Self, Self::PrivateKey);
    fn stake_table_entry(&self, stake: u64) -> Self::StakeTableEntry;
    fn public_key(entry: &Self::StakeTableEntry) -> Self;
    fn public_parameter(
        stake_entries: Vec<Self::StakeTableEntry>,
        threshold: U256,
    ) -> Self::QcParams;
    fn check(
        real_qc_pp: &Self::QcParams,
        data: &[u8],
        qc: &Self::QcType,
    ) -> bool;
    fn sig_proof(
        signature: &Self::QcType,
    ) -> (Self::PureAssembledSignatureType, BitVec);
    fn assemble(
        real_qc_pp: &Self::QcParams,
        signers: &BitSlice,
        sigs: &[Self::PureAssembledSignatureType],
    ) -> Self::QcType;
    fn genesis_proposer_pk() -> Self;
}

Trait for abstracting public key signatures Self is the public key type

Required Associated Types

type PrivateKey: PrivateSignatureKey

The private key type for this signature algorithm

type StakeTableEntry: StakeTableEntryType<Self> + Send + Sync + Clone + Debug + Hash + Eq + Serialize + for<'a> Deserialize<'a>

The type of the entry that contain both public key and stake value

type QcParams: Send + Sync + Clone + Debug + Hash

The type of the quorum certificate parameters used for assembled signature

type PureAssembledSignatureType: Send + Sync + Clone + Debug + Hash + PartialEq + Eq + Serialize + for<'a> Deserialize<'a> + Into<TaggedBase64> + for<'a> TryFrom<&'a TaggedBase64>

The type of the assembled signature, without BitVec

type QcType: Send + Sync + Clone + Debug + Hash + PartialEq + Eq + Serialize + for<'a> Deserialize<'a>

The type of the assembled qc: assembled signature + BitVec

type SignError: Error + Send + Sync

Type of error that can occur when signing data

Required Methods

fn validate( &self, signature: &Self::PureAssembledSignatureType, data: &[u8], ) -> bool

Validate a signature

fn sign( private_key: &Self::PrivateKey, data: &[u8], ) -> Result<Self::PureAssembledSignatureType, Self::SignError>

Produce a signature

Errors

If unable to sign the data with the key

fn from_private(private_key: &Self::PrivateKey) -> Self

Produce a public key from a private key

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

Serialize a public key to bytes

fn from_bytes(bytes: &[u8]) -> Result<Self, SerializationError>

Deserialize a public key from bytes

Errors

Will return Err if deserialization fails

fn generated_from_seed_indexed( seed: [u8; 32], index: u64, ) -> (Self, Self::PrivateKey)

Generate a new key pair

fn stake_table_entry(&self, stake: u64) -> Self::StakeTableEntry

get the stake table entry from the public key and stake value

fn public_key(entry: &Self::StakeTableEntry) -> Self

only get the public key from the stake table entry

fn public_parameter( stake_entries: Vec<Self::StakeTableEntry>, threshold: U256, ) -> Self::QcParams

get the public parameter for the assembled signature checking

fn check(real_qc_pp: &Self::QcParams, data: &[u8], qc: &Self::QcType) -> bool

check the quorum certificate for the assembled signature

fn sig_proof( signature: &Self::QcType, ) -> (Self::PureAssembledSignatureType, BitVec)

get the assembled signature and the BitVec separately from the assembled signature

fn assemble( real_qc_pp: &Self::QcParams, signers: &BitSlice, sigs: &[Self::PureAssembledSignatureType], ) -> Self::QcType

assemble the signature from the partial signature and the indication of signers in BitVec

fn genesis_proposer_pk() -> Self

generates the genesis public key. Meant to be dummy/filler

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl SignatureKey for VerKey

type PrivateKey = SignKey

type StakeTableEntry = StakeTableEntry<VerKey>

type QcParams = QcParams<VerKey, <BLSOverBN254CurveSignatureScheme as SignatureScheme>::PublicParameter>

type PureAssembledSignatureType = <BLSOverBN254CurveSignatureScheme as SignatureScheme>::Signature

type QcType = (<VerKey as SignatureKey>::PureAssembledSignatureType, BitVec)

type SignError = SignatureError

fn validate( &self, signature: &<VerKey as SignatureKey>::PureAssembledSignatureType, data: &[u8], ) -> bool

fn sign( sk: &<VerKey as SignatureKey>::PrivateKey, data: &[u8], ) -> Result<<VerKey as SignatureKey>::PureAssembledSignatureType, <VerKey as SignatureKey>::SignError>

fn from_private(private_key: &<VerKey as SignatureKey>::PrivateKey) -> VerKey

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

fn from_bytes(bytes: &[u8]) -> Result<VerKey, SerializationError>

fn generated_from_seed_indexed( seed: [u8; 32], index: u64, ) -> (VerKey, <VerKey as SignatureKey>::PrivateKey)

fn stake_table_entry( &self, stake: u64, ) -> <VerKey as SignatureKey>::StakeTableEntry

fn public_key(entry: &<VerKey as SignatureKey>::StakeTableEntry) -> VerKey

fn public_parameter( stake_entries: Vec<<VerKey as SignatureKey>::StakeTableEntry>, threshold: U256, ) -> <VerKey as SignatureKey>::QcParams

fn check( real_qc_pp: &<VerKey as SignatureKey>::QcParams, data: &[u8], qc: &<VerKey as SignatureKey>::QcType, ) -> bool

fn sig_proof( signature: &<VerKey as SignatureKey>::QcType, ) -> (<VerKey as SignatureKey>::PureAssembledSignatureType, BitVec)

fn assemble( real_qc_pp: &<VerKey as SignatureKey>::QcParams, signers: &BitSlice, sigs: &[<VerKey as SignatureKey>::PureAssembledSignatureType], ) -> <VerKey as SignatureKey>::QcType

fn genesis_proposer_pk() -> VerKey

Implementors