Struct PrimitiveSignature

pub struct PrimitiveSignature { /* private fields */ }

An Ethereum ECDSA signature.

Implementations

impl PrimitiveSignature

pub fn decode_rlp_vrs( buf: &mut &[u8], decode_parity: impl FnOnce(&mut &[u8]) -> Result<bool, Error>, ) -> Result<PrimitiveSignature, Error>

Available on crate feature rlp only.

Decode an RLP-encoded VRS signature. Accepts decode_parity closure which allows to customize parity decoding and possibly extract additional data from it (e.g chain_id for legacy signature).

impl PrimitiveSignature

pub fn new(r: Uint<256, 4>, s: Uint<256, 4>, v: bool) -> PrimitiveSignature

Instantiate a new signature from r, s, and v values.

pub fn into_inner(self) -> Signature<Secp256k1>

👎Deprecated: use Signature::to_k256 instead

Available on crate feature k256 only.

Returns the inner ECDSA signature.

pub fn to_k256(self) -> Result<Signature<Secp256k1>, Error>

Available on crate feature k256 only.

Returns the inner ECDSA signature.

pub fn from_signature_and_parity( sig: Signature<Secp256k1>, v: bool, ) -> PrimitiveSignature

Available on crate feature k256 only.

Instantiate from a signature and recovery id

pub fn from_scalars_and_parity( r: FixedBytes<32>, s: FixedBytes<32>, parity: bool, ) -> PrimitiveSignature

Creates a PrimitiveSignature from the serialized r and s scalar values, which comprise the ECDSA signature, alongside a v value, used to determine the recovery ID.

pub fn normalize_s(&self) -> Option<PrimitiveSignature>

Normalizes the signature into “low S” form as described in BIP 0062: Dealing with Malleability.

pub const fn recid(&self) -> RecoveryId

Available on crate feature k256 only.

Returns the recovery ID.

pub fn recover_address_from_msg<T>( &self, msg: T, ) -> Result<Address, SignatureError>

where T: AsRef<[u8]>,

Available on crate feature k256 only.

Recovers an Address from this signature and the given message by first prefixing and hashing the message according to EIP-191.

pub fn recover_address_from_prehash( &self, prehash: &FixedBytes<32>, ) -> Result<Address, SignatureError>

Available on crate feature k256 only.

Recovers an Address from this signature and the given prehashed message.

pub fn recover_from_msg<T>( &self, msg: T, ) -> Result<VerifyingKey<Secp256k1>, SignatureError>

where T: AsRef<[u8]>,

Available on crate feature k256 only.

Recovers a VerifyingKey from this signature and the given message by first prefixing and hashing the message according to EIP-191.

pub fn recover_from_prehash( &self, prehash: &FixedBytes<32>, ) -> Result<VerifyingKey<Secp256k1>, SignatureError>

Available on crate feature k256 only.

Recovers a VerifyingKey from this signature and the given prehashed message.

pub fn from_bytes_and_parity(bytes: &[u8], parity: bool) -> PrimitiveSignature

Parses a signature from a byte slice, with a v value

Panics

If the slice is not at least 64 bytes long.

pub const fn r(&self) -> Uint<256, 4>

Returns the r component of this signature.

pub const fn s(&self) -> Uint<256, 4>

Returns the s component of this signature.

pub const fn v(&self) -> bool

Returns the recovery ID as a bool.

pub fn as_bytes(&self) -> [u8; 65]

Returns the byte-array representation of this signature.

The first 32 bytes are the r value, the second 32 bytes the s value and the final byte is the v value in ‘Electrum’ notation.

pub const fn with_parity(self, v: bool) -> PrimitiveSignature

Sets the recovery ID by normalizing a v value.

pub fn rlp_rs_len(&self) -> usize

Available on crate feature rlp only.

Length of RLP RS field encoding

pub fn write_rlp_rs(&self, out: &mut dyn BufMut)

Available on crate feature rlp only.

Write R and S to an RLP buffer in progress.

pub fn write_rlp_vrs(&self, out: &mut dyn BufMut, v: impl Encodable)

Available on crate feature rlp only.

Write the VRS to the output.

Trait Implementations

impl<'a> Arbitrary<'a> for PrimitiveSignature

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<PrimitiveSignature, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Arbitrary for PrimitiveSignature

Available on crate feature arbitrary only.

type Parameters = ()

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

type Strategy = Map<<(Uint<256, 4>, Uint<256, 4>, bool) as Arbitrary>::Strategy, fn(_: (Uint<256, 4>, Uint<256, 4>, bool)) -> PrimitiveSignature>

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

fn arbitrary_with( _: <PrimitiveSignature as Arbitrary>::Parameters, ) -> <PrimitiveSignature 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 Clone for PrimitiveSignature

fn clone(&self) -> PrimitiveSignature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compact for PrimitiveSignature

fn to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

Takes a buffer which can be written to. Ideally, it returns the length written to.

fn from_compact(buf: &[u8], identifier: usize) -> (PrimitiveSignature, &[u8])

Takes a buffer which can be read from. Returns the object and buf with its internal cursor advanced (eg..advance(len)).

fn specialized_to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

“Optional”: If there’s no good reason to use it, don’t.

fn specialized_from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

“Optional”: If there’s no good reason to use it, don’t.

impl Debug for PrimitiveSignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PrimitiveSignature

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&PrimitiveSignature> for [u8; 65]

fn from(value: &PrimitiveSignature) -> [u8; 65]

Converts to this type from the input type.

impl From<&PrimitiveSignature> for Vec<u8>

fn from(value: &PrimitiveSignature) -> Vec<u8>

Converts to this type from the input type.

impl From<(Signature<Secp256k1>, RecoveryId)> for PrimitiveSignature

Available on crate feature k256 only.

fn from(value: (Signature<Secp256k1>, RecoveryId)) -> PrimitiveSignature

Converts to this type from the input type.

impl From<PrimitiveSignature> for [u8; 65]

fn from(value: PrimitiveSignature) -> [u8; 65]

Converts to this type from the input type.

impl From<PrimitiveSignature> for Vec<u8>

fn from(value: PrimitiveSignature) -> Vec<u8>

Converts to this type from the input type.

impl FromStr for PrimitiveSignature

type Err = SignatureError

The associated error which can be returned from parsing.

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

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

impl Hash for PrimitiveSignature

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 PartialEq for PrimitiveSignature

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

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<'a> TryFrom<&'a [u8]> for PrimitiveSignature

fn try_from( bytes: &'a [u8], ) -> Result<PrimitiveSignature, <PrimitiveSignature as TryFrom<&'a [u8]>>::Error>

Parses a raw signature which is expected to be 65 bytes long where the first 32 bytes is the r value, the second 32 bytes the s value and the final byte is the v value in ‘Electrum’ notation.

type Error = SignatureError

The type returned in the event of a conversion error.

impl TryFrom<PrimitiveSignature> for Signature<Secp256k1>

Available on crate feature k256 only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: PrimitiveSignature, ) -> Result<Signature<Secp256k1>, <Signature<Secp256k1> as TryFrom<PrimitiveSignature>>::Error>

Performs the conversion.

impl Copy for PrimitiveSignature

impl Eq for PrimitiveSignature

impl StructuralPartialEq for PrimitiveSignature

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 72 bytes