Struct Signature

pub struct Signature { /* private fields */ }

👎Deprecated since 0.8.15: use PrimitiveSignature instead

An Ethereum ECDSA signature.

Implementations

impl Signature

pub fn decode_rlp_vrs(buf: &mut &[u8]) -> Result<Signature, Error>

Decode an RLP-encoded VRS signature.

impl Signature

pub const fn new(r: Uint<256, 4>, s: Uint<256, 4>, v: Parity) -> Signature

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

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

👎Deprecated: use Signature::to_k256 instead

Returns the inner ECDSA signature.

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

Returns the inner ECDSA signature.

pub fn from_signature_and_parity<T, E>( sig: Signature<Secp256k1>, parity: T, ) -> Result<Signature, SignatureError>

where T: TryInto<Parity, Error = E>, E: Into<SignatureError>,

Instantiate from a signature and recovery id

pub fn from_scalars_and_parity<T, E>( r: FixedBytes<32>, s: FixedBytes<32>, parity: T, ) -> Result<Signature, SignatureError>

where T: TryInto<Parity, Error = E>, E: Into<SignatureError>,

Creates a Signature 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<Signature>

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

pub const fn recid(&self) -> RecoveryId

Returns the recovery ID.

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

where T: AsRef<[u8]>,

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>

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]>,

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>

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

pub fn from_bytes_and_parity<T, E>( bytes: &[u8], parity: T, ) -> Result<Signature, SignatureError>

where T: TryInto<Parity, Error = E>, E: Into<SignatureError>,

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

Panics

If the slice is not at least 64 bytes long.

pub fn from_rs_and_parity<T, E>( r: Uint<256, 4>, s: Uint<256, 4>, parity: T, ) -> Result<Signature, SignatureError>

where T: TryInto<Parity, Error = E>, E: Into<SignatureError>,

Instantiate from v, r, s.

pub fn with_chain_id(self, chain_id: u64) -> Signature

Modifies the recovery ID by applying EIP-155 to a v value.

pub fn with_parity_bool(self) -> Signature

Modifies the recovery ID by dropping any [EIP-155] v value, converting to a simple parity bool.

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) -> Parity

Returns the recovery ID as a u8.

pub const fn chain_id(&self) -> Option<u64>

Returns the chain ID associated with the V value, if this signature is replay-protected by EIP-155.

pub const fn has_eip155_value(&self) -> bool

Returns true if the signature is replay-protected by EIP-155.

This is true if the V value is 35 or greater. Values less than 35 are either not replay protected (27/28), or are invalid.

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 fn with_parity<T>(self, parity: T) -> Signature

where T: Into<Parity>,

Sets the recovery ID by normalizing a v value.

pub fn rlp_rs_len(&self) -> usize

Length of RLP RS field encoding

pub fn rlp_vrs_len(&self) -> usize

Length of RLP V field encoding

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

Write R and S to an RLP buffer in progress.

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

Write the V to an RLP buffer without using EIP-155.

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

Write the VRS to the output. The V will always be 27 or 28.

Trait Implementations

impl<'a> Arbitrary<'a> for Signature

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Signature, 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 Signature

type Parameters = ()

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

type Strategy = FilterMap<<(Uint<256, 4>, Uint<256, 4>, Parity) as Arbitrary>::Strategy, fn(_: (Uint<256, 4>, Uint<256, 4>, Parity)) -> Option<Signature>>

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

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

fn clone(&self) -> Signature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Signature

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

Formats the value using the given formatter.

impl Decodable for Signature

fn decode(buf: &mut &[u8]) -> Result<Signature, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl<'de> Deserialize<'de> for Signature

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for Signature

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

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

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

Converts to this type from the input type.

impl From<&Signature> for Vec<u8>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<Signature> for [u8; 65]

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

Converts to this type from the input type.

impl From<Signature> for Vec<u8>

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

Converts to this type from the input type.

impl FromStr for Signature

type Err = SignatureError

The associated error which can be returned from parsing.

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

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

impl Hash for Signature

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 Signature

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

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 Signature

fn try_from( bytes: &'a [u8], ) -> Result<Signature, <Signature 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<Signature> for Signature<Secp256k1>

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for Signature

impl Eq for Signature

impl StructuralPartialEq for Signature

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: 80 bytes