[−][src]Struct k256::ecdsa::recoverable::Signature

pub struct Signature { /* fields omitted */ }

This is supported on crate feature ecdsa-core only.

Ethereum-style "recoverable signatures" which allow for the recovery of the signer's VerifyKey from the signature itself.

This format consists of Signature followed by a 1-byte recovery Id (65-bytes total):

r: 32-byte integer, big endian
s: 32-byte integer, big endian
v: 1-byte recovery Id

Implementations

`impl Signature`[src]

`pub fn new(signature: &Signature, recovery_id: Id) -> Result<Self, Error>`[src]

Create a new recoverable ECDSA/secp256k1 signature from a regular fixed-size signature and an associated recovery Id.

This is an "unchecked" conversion and assumes the provided Id is valid for this signature.

`pub fn recovery_id(self) -> Id`[src]

Get the recovery Id for this signature

`pub fn from_trial_recovery( public_key: &VerifyKey, msg: &[u8], signature: &Signature ) -> Result<Self, Error>`[src]

This is supported on crate features ecdsa and keccak256 only.

Given a public key, message, and signature, use trial recovery to determine if a suitable recovery ID exists, or return an error otherwise.

Assumes Keccak256 as the message digest function. Use Signature::from_digest_trial_recovery to support other digest functions.

`pub fn from_digest_trial_recovery<D>( public_key: &VerifyKey, digest: D, signature: &Signature ) -> Result<Self, Error> where D: Clone + Digest<OutputSize = U32>,` [src]

This is supported on crate feature ecdsa only.

Given a public key, message digest, and signature, use trial recovery to determine if a suitable recovery ID exists, or return an error otherwise.

`pub fn recover_verify_key(&self, msg: &[u8]) -> Result<VerifyKey, Error>`[src]

This is supported on crate features ecdsa and keccak256 only.

Recover the public key used to create the given signature as a VerifyKey.

`pub fn recover_verify_key_from_digest<D>( &self, msg_digest: D ) -> Result<VerifyKey, Error> where D: Digest<OutputSize = U32>,` [src]

This is supported on crate feature ecdsa only.

Recover the public key used to create the given signature as a VerifyKey from the provided precomputed [Digest].

`pub fn recover_verify_key_from_digest_bytes( &self, digest_bytes: &FieldBytes ) -> Result<VerifyKey, Error>`[src]

This is supported on crate feature ecdsa only.

Recover the public key used to create the given signature as a VerifyKey from the raw bytes of a message digest.

`pub fn r(&self) -> NonZeroScalar`[src]

This is supported on crate feature ecdsa only.

Parse the r component of this signature to a NonZeroScalar

`pub fn s(&self) -> NonZeroScalar`[src]

This is supported on crate feature ecdsa only.

Parse the s component of this signature to a NonZeroScalar

Trait Implementations

`impl AsRef<[u8]> for Signature`[src]

`fn as_ref(&self) -> &[u8]`[src]

`impl Clone for Signature`[src]

`fn clone(&self) -> Signature`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Copy for Signature`[src]

`impl Debug for Signature`[src]

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

`impl<D> DigestSigner<D, Signature> for SigningKey where D: BlockInput + FixedOutput<OutputSize = U32> + Clone + Default + Reset + Update,` [src]

`fn try_sign_digest(&self, digest: D) -> Result<Signature, Error>`[src]

`fn sign_digest(&self, digest: D) -> S`[src]

`impl<D> DigestVerifier<D, Signature> for VerifyKey where D: Digest<OutputSize = U32>,` [src]

`fn verify_digest(&self, digest: D, signature: &Signature) -> Result<(), Error>`[src]

`impl Eq for Signature`[src]

`impl From<Signature> for Signature`[src]

`fn from(sig: Signature) -> Self`[src]

`impl PartialEq<Signature> for Signature`[src]

`fn eq(&self, other: &Self) -> bool`[src]

`#[must_use]fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

`impl PrehashSignature for Signature`[src]

`type Digest = Keccak256`

Preferred Digest algorithm to use when computing this signature type.

`impl<D> RandomizedDigestSigner<D, Signature> for SigningKey where D: BlockInput + FixedOutput<OutputSize = U32> + Clone + Default + Reset + Update,` [src]

`fn try_sign_digest_with_rng( &self, rng: impl CryptoRng + RngCore, digest: D ) -> Result<Signature, Error>`[src]

`fn sign_digest_with_rng(&self, rng: impl RngCore + CryptoRng, digest: D) -> S`[src]

`impl Signature for Signature`[src]

`fn from_bytes(bytes: &[u8]) -> Result<Self, Error>`[src]

`fn as_bytes(&self) -> &[u8]`[src]

`impl<'_> TryFrom<&'_ [u8]> for Signature`[src]

`type Error = Error`

The type returned in the event of a conversion error.

`fn try_from(bytes: &[u8]) -> Result<Self, Error>`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Signature`

`impl Send for Signature`

`impl Sync for Signature`

`impl Unpin for Signature`

`impl UnwindSafe for Signature`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<A, T> AsBits<T> for A where A: AsRef<[T]>, T: BitStore + BitMemory,`

`pub fn as_bits<O>(&self) -> &BitSlice<O, T> where O: BitOrder,`

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T`

`fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: AsRef<T>, T: 'a,`

`fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where R: 'a, Self: AsMut<T>, T: 'a,`

`impl<T> PipeBorrow for T`

`fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Borrow<T>, T: 'a,`

`fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: BorrowMut<T>, T: 'a,`

`impl<T> PipeDeref for T`

`fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where R: 'a, Self: Deref,`

`fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where R: 'a, Self: DerefMut,`

`impl<T> PipeRef for T`

`fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> Tap for T`

`fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef<U> for T where U: ?Sized,`

`fn tap_ref<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`fn tap_ref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`fn tap_ref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`impl<T, U> TapBorrow<U> for T where U: ?Sized,`

`fn tap_borrow<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`fn tap_borrow_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`fn tap_borrow_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`impl<T> TapDeref for T`

`fn tap_deref<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`fn tap_deref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`fn tap_deref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> TryConv for T`

`fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]