Struct hotshot_stake_table::vec_based::config::QCVerKey

pub struct QCVerKey(pub(crate) Projective<<Config as BnConfig>::G2Config>);

BLS verification key as indexing key Signature public verification key

Tuple Fields

0: Projective<<Config as BnConfig>::G2Config>

Implementations

impl VerKey

pub fn to_affine(&self) -> Affine<<Config as BnConfig>::G2Config>

Convert the verification key into the affine form.

impl VerKey

pub fn internal(&self) -> Projective<<Config as BnConfig>::G2Config>

Get the internal of verifying key, namely a curve Point

pub fn verify<B>( &self, msg: &[u8], sig: &Signature, csid: B, ) -> Result<(), SignatureError>

where B: AsRef<[u8]>,

Signature verification function

Trait Implementations

impl BuilderSignatureKey for VerKey

type BuilderPrivateKey = SignKey

The type of the keys builder would use to sign its messages

type BuilderSignature = <BLSOverBN254CurveSignatureScheme as SignatureScheme>::Signature

The type of the signature builder would use to sign its messages

type SignError = SignatureError

Type of error that can occur when signing data

fn sign_builder_message( private_key: &<VerKey as BuilderSignatureKey>::BuilderPrivateKey, data: &[u8], ) -> Result<<VerKey as BuilderSignatureKey>::BuilderSignature, <VerKey as BuilderSignatureKey>::SignError>

sign the message with the builder’s private key

fn validate_builder_signature( &self, signature: &<VerKey as BuilderSignatureKey>::BuilderSignature, data: &[u8], ) -> bool

validate the message with the builder’s public key

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

Generate a new key pair

fn validate_fee_signature<Metadata>( &self, signature: &Self::BuilderSignature, fee_amount: u64, metadata: &Metadata, vid_commitment: &<VidSchemeType as VidScheme>::Commit, ) -> bool

where Metadata: EncodeBytes,

validate signature over sequencing fee information with the builder’s public key

fn validate_sequencing_fee_signature_marketplace( &self, signature: &Self::BuilderSignature, fee_amount: u64, view_number: u64, ) -> bool

validate signature over sequencing fee information with the builder’s public key (marketplace version)

fn validate_bundle_signature<TYPES>(&self, bundle: Bundle<TYPES>) -> bool

where TYPES: NodeType<BuilderSignatureKey = Self>,

validate the bundle’s signature using the builder’s public key

fn validate_block_info_signature( &self, signature: &Self::BuilderSignature, block_size: u64, fee_amount: u64, payload_commitment: &BuilderCommitment, ) -> bool

validate signature over block information with the builder’s public key

fn sign_fee<Metadata>( private_key: &Self::BuilderPrivateKey, fee_amount: u64, metadata: &Metadata, vid_commitment: &<VidSchemeType as VidScheme>::Commit, ) -> Result<Self::BuilderSignature, Self::SignError>

where Metadata: EncodeBytes,

sign sequencing fee offer for proposed payload

fn sign_sequencing_fee_marketplace( private_key: &Self::BuilderPrivateKey, fee_amount: u64, view_number: u64, ) -> Result<Self::BuilderSignature, Self::SignError>

sign fee offer for proposed payload (marketplace version)

fn sign_bundle<TYPES>( private_key: &Self::BuilderPrivateKey, transactions: &[<TYPES as NodeType>::Transaction], ) -> Result<Self::BuilderSignature, Self::SignError>

where TYPES: NodeType,

sign transactions (marketplace version)

fn sign_block_info( private_key: &Self::BuilderPrivateKey, block_size: u64, fee_amount: u64, payload_commitment: &BuilderCommitment, ) -> Result<Self::BuilderSignature, Self::SignError>

sign information about offered block

impl CanonicalDeserialize for VerKey

fn deserialize_with_mode<R>( reader: R, compress: Compress, validate: Validate, ) -> Result<VerKey, SerializationError>

where R: Read,

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl CanonicalSerialize for VerKey

fn serialize_with_mode<W>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

where W: Write,

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl Clone for VerKey

fn clone(&self) -> VerKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VerKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for VerKey

fn deserialize<__D>( __deserializer: __D, ) -> Result<VerKey, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for VerKey

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

Formats the value using the given formatter.

impl From<&SignKey> for VerKey

fn from(sk: &SignKey) -> VerKey

Converts to this type from the input type.

impl FromStr for VerKey

type Err = Tb64Error

The associated error which can be returned from parsing.

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

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

impl Hash for VerKey

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 Ord for VerKey

fn cmp(&self, other: &VerKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for VerKey

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

fn partial_cmp(&self, other: &VerKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for VerKey

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 SignatureKey for VerKey

type PrivateKey = SignKey

The private key type for this signature algorithm

type StakeTableEntry = StakeTableEntry<VerKey>

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

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

The type of the quorum certificate parameters used for assembled signature

type PureAssembledSignatureType = <BLSOverBN254CurveSignatureScheme as SignatureScheme>::Signature

The type of the assembled signature, without BitVec

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

The type of the assembled qc: assembled signature + BitVec

type SignError = SignatureError

Type of error that can occur when signing data

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

Validate a signature

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

Produce a signature

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

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<VerKey, SerializationError>

Deserialize a public key from bytes

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

Generate a new key pair

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

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

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

only get the public key from the stake table entry

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

get the public parameter for the assembled signature checking

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

check the quorum certificate for the assembled signature, returning Ok(()) if it is valid.

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

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

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

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

fn genesis_proposer_pk() -> VerKey

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

impl Tagged for VerKey

fn tag() -> String

impl ToFields<Fp<MontBackend<FqConfig, 4>, 4>> for VerKey

const SIZE: usize = 2usize

The number of field elements needed to represent the given struct.

fn to_fields(&self) -> Vec<Fq>

Convert the given struct into a list of field elements.

impl ToFields<Fp<MontBackend<FrConfig, 4>, 4>> for QCVerKey

const SIZE: usize = 3usize

The number of field elements needed to represent the given struct.

fn to_fields(&self) -> Vec<FieldType>

Convert the given struct into a list of field elements.

impl TryFrom<&TaggedBase64> for VerKey

type Error = Tb64Error

The type returned in the event of a conversion error.

fn try_from( t: &TaggedBase64, ) -> Result<VerKey, <VerKey as TryFrom<&TaggedBase64>>::Error>

Performs the conversion.

impl TryFrom<TaggedBase64> for VerKey

type Error = Tb64Error

The type returned in the event of a conversion error.

fn try_from( t: TaggedBase64, ) -> Result<VerKey, <VerKey as TryFrom<TaggedBase64>>::Error>

Performs the conversion.

impl Valid for VerKey

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a VerKey> + Send, ) -> Result<(), SerializationError>

where VerKey: 'a,

impl Zeroize for VerKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Copy for VerKey

impl Eq for VerKey

impl StructuralPartialEq for VerKey