Struct BlockSignatures 

pub struct BlockSignatures { /* private fields */ }

The set of validator signatures over a block header ordered by validator key.

The signatures are expected to be ordered with respect to a validator set (see ValidatorKeys): the signature in slot i is produced by, and verified against, the validator key at index i. Every validator in the set must sign; there is no partial-signing or threshold support.

This is a plain, unchecked container: neither BlockSignatures::new nor deserialization verify anything about the signatures they hold. The only way to establish that a BlockSignatures value is valid is to call BlockSignatures::verify_against.

Implementations

impl BlockSignatures

pub fn new(signatures: Vec<Signature>) -> Result<Self, BlockSignaturesError>

Returns a new BlockSignatures from the provided signatures, ordered positionally.

This performs no validation beyond checking that the number of signatures does not exceed ValidatorKeys::MAX: the caller is responsible for ordering signatures to align with the validator set it is meant to be checked against. Call BlockSignatures::verify_against to establish that the signatures are valid.

pub fn as_signatures(&self) -> &[Signature]

Returns the positional signatures, where signature i corresponds to validator key i.

pub fn len(&self) -> usize

Returns the number of signatures.

pub fn is_empty(&self) -> bool

Returns true if there are no signatures.

pub fn verify_against( &self, block_commitment: Word, validator_keys: &ValidatorKeys, ) -> Result<(), SignatureVerificationError>

Verifies the signatures positionally against validator_keys over block_commitment.

This is the canonical verification of an ordered signature set, and the only place that establishes a BlockSignatures value is valid: the number of signatures must match the number of validator keys, and the signature in slot i must verify against the validator key at index i.

Errors

Returns an error if the number of signatures does not match the number of validator keys, or if a signature does not verify against the validator key at its position.

Trait Implementations

impl Clone for BlockSignatures

fn clone(&self) -> BlockSignatures

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockSignatures

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

Formats the value using the given formatter.

impl Deserializable for BlockSignatures

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl Eq for BlockSignatures

impl PartialEq for BlockSignatures

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

Equality operator ==.

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

Inequality operator !=.

impl Serializable for BlockSignatures

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

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

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl StructuralPartialEq for BlockSignatures