Struct Signature

pub struct Signature { /* private fields */ }

An Ethereum ECDSA signature.

Implementations

impl Signature

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

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 Signature

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

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

pub fn from_raw(bytes: &[u8]) -> Result<Signature, SignatureError>

Parses a 65-byte long raw signature.

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.

pub fn from_raw_array(bytes: &[u8; 65]) -> Result<Signature, SignatureError>

Parses a 65-byte long raw signature.

See from_raw.

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

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

Panics

If the slice is not at least 64 bytes long.

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 from_erc2098(bytes: &[u8]) -> Signature

Decode the signature from the ERC-2098 compact representation.

The first 32 bytes are the r value, and the next 32 bytes are the s value with yParity in the top bit of the s value, as described in ERC-2098.

See https://eips.ethereum.org/EIPS/eip-2098

Panics

If the slice is not at least 64 bytes long.

pub fn as_erc2098(&self) -> [u8; 64]

Returns the ERC-2098 compact representation of this signature.

The first 32 bytes are the r value, and the next 32 bytes are the s value with yParity in the top bit of the s value, as described in ERC-2098.

See https://eips.ethereum.org/EIPS/eip-2098

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

Sets the recovery ID by normalizing a v value.

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( sig: Signature<Secp256k1>, v: bool, ) -> Signature

Instantiate from a signature and recovery id

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

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.

If s is already normalized, returns None.

pub fn normalized_s(self) -> Signature

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

If s is already normalized, returns self.

pub 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 r(&self) -> Uint<256, 4>

Returns the r component of this signature.

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

Returns the s component of this signature.

pub fn v(&self) -> bool

Returns the recovery ID as a bool.

pub fn rlp_rs_len(&self) -> usize

Length of RLP RS 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_vrs(&self, out: &mut dyn BufMut, v: impl Encodable)

Write the VRS to the output.

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 = Map<<(Uint<256, 4>, Uint<256, 4>, bool) as Arbitrary>::Strategy, fn((Uint<256, 4>, Uint<256, 4>, bool)) -> 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 Compact for Signature

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) -> (Signature, &[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 Signature

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

Formats the value using the given formatter.

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 Display for Signature

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

Formats the value using the given formatter.

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 InMemorySize for Signature

fn size(&self) -> usize

Returns a heuristic for the in-memory size of a struct.

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<Eip4844> SignableTransaction<Signature> for EthereumTypedTransaction<Eip4844>

where Eip4844: SignableTransaction<Signature>,

fn set_chain_id(&mut self, chain_id: u64)

Sets chain_id.

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

RLP-encodes the transaction for signing.

fn payload_len_for_signature(&self) -> usize

Outputs the length of the signature RLP encoding for the transaction.

fn set_chain_id_checked(&mut self, chain_id: u64) -> bool

Set chain_id if it is not already set. Checks that the provided chain_id matches the existing chain_id if it is already set, returning false if they do not match.

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

RLP-encodes the transaction for signing it. Used to calculate signature_hash.

fn signature_hash(&self) -> FixedBytes<32>

Calculate the signing hash for the transaction.

fn into_signed(self, signature: Signature) -> Signed<Self, Signature>

where Self: Sized,

Convert to a [Signed] object.

impl TryFrom<&[u8]> for Signature

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

Parses a 65-byte long raw signature.

See from_raw.

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