Struct flow_sdk::algorithms::secp256k1::Secp256k1

pub struct Secp256k1<C> where
    C: Context,  { /* fields omitted */ }

The secp256k1 engine, used to execute all signature operations

Implementations

impl<C> Secp256k1<C> where
    C: Context, 

pub fn gen_new() -> Secp256k1<C>

Lets you create a context in a generic manner(sign/verify/all)

impl Secp256k1<All>

pub fn new() -> Secp256k1<All>

Creates a new Secp256k1 context with all capabilities

impl Secp256k1<SignOnly>

pub fn signing_only() -> Secp256k1<SignOnly>

Creates a new Secp256k1 context that can only be used for signing

impl Secp256k1<VerifyOnly>

pub fn verification_only() -> Secp256k1<VerifyOnly>

Creates a new Secp256k1 context that can only be used for verification

impl<'buf, C> Secp256k1<C> where
    C: 'buf + Context, 

pub fn preallocated_gen_new(
    buf: &'buf mut [AlignedType]
) -> Result<Secp256k1<C>, Error>

Lets you create a context with preallocated buffer in a generic manner(sign/verify/all)

impl<'buf> Secp256k1<AllPreallocated<'buf>>

pub fn preallocated_new(
    buf: &'buf mut [AlignedType]
) -> Result<Secp256k1<AllPreallocated<'buf>>, Error>

Creates a new Secp256k1 context with all capabilities

pub fn preallocate_size() -> usize

Uses the ffi secp256k1_context_preallocated_size to check the memory size needed for a context

pub unsafe fn from_raw_all(
    raw_ctx: *mut Context
) -> ManuallyDrop<Secp256k1<AllPreallocated<'buf>>>

Create a context from a raw context.

Safety

This is highly unsafe, due to the number of conditions that aren’t checked.

• raw_ctx needs to be a valid Secp256k1 context pointer. that was generated by exactly the same code/version of the libsecp256k1 used here.
• The capabilities (All/SignOnly/VerifyOnly) of the context must match the flags passed to libsecp256k1 when generating the context.
• The user must handle the freeing of the context(using the correct functions) by himself.
• Violating these may lead to Undefined Behavior.

impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>>

pub fn preallocated_signing_only(
    buf: &'buf mut [AlignedType]
) -> Result<Secp256k1<SignOnlyPreallocated<'buf>>, Error>

Creates a new Secp256k1 context that can only be used for signing

pub fn preallocate_signing_size() -> usize

Uses the ffi secp256k1_context_preallocated_size to check the memory size needed for the context

pub unsafe fn from_raw_signining_only(
    raw_ctx: *mut Context
) -> ManuallyDrop<Secp256k1<SignOnlyPreallocated<'buf>>>

Create a context from a raw context.

Safety

This is highly unsafe, due to the number of conditions that aren’t checked.

• raw_ctx needs to be a valid Secp256k1 context pointer. that was generated by exactly the same code/version of the libsecp256k1 used here.
• The capabilities (All/SignOnly/VerifyOnly) of the context must match the flags passed to libsecp256k1 when generating the context.
• The user must handle the freeing of the context(using the correct functions) by himself.
• This list is not exhaustive, and any violation may lead to Undefined Behavior.,

impl<'buf> Secp256k1<VerifyOnlyPreallocated<'buf>>

pub fn preallocated_verification_only(
    buf: &'buf mut [AlignedType]
) -> Result<Secp256k1<VerifyOnlyPreallocated<'buf>>, Error>

Creates a new Secp256k1 context that can only be used for verification

pub fn preallocate_verification_size() -> usize

Uses the ffi secp256k1_context_preallocated_size to check the memory size needed for the context

pub unsafe fn from_raw_verification_only(
    raw_ctx: *mut Context
) -> ManuallyDrop<Secp256k1<VerifyOnlyPreallocated<'buf>>>

Create a context from a raw context.

Safety

This is highly unsafe, due to the number of conditions that aren’t checked.

• raw_ctx needs to be a valid Secp256k1 context pointer. that was generated by exactly the same code/version of the libsecp256k1 used here.
• The capabilities (All/SignOnly/VerifyOnly) of the context must match the flags passed to libsecp256k1 when generating the context.
• The user must handle the freeing of the context(using the correct functions) by himself.
• This list is not exhaustive, and any violation may lead to Undefined Behavior.,

impl<C> Secp256k1<C> where
    C: Signing, 

pub fn schnorrsig_sign_no_aux_rand(
    &self,
    msg: &Message,
    keypair: &KeyPair
) -> Signature

Create a schnorr signature without using any auxiliary random data.

pub fn schnorrsig_sign_with_aux_rand(
    &self,
    msg: &Message,
    keypair: &KeyPair,
    aux_rand: &[u8; 32]
) -> Signature

Create a Schnorr signature using the given auxiliary random data.

pub fn schnorrsig_sign_with_rng<R>(
    &self,
    msg: &Message,
    keypair: &KeyPair,
    rng: &mut R
) -> Signature where
    R: Rng + CryptoRng, 

Create a schnorr signature using the given random number generator to generate the auxiliary random data. Requires compilation with “rand” feature.

pub fn schnorrsig_verify(
    &self,
    sig: &Signature,
    msg: &Message,
    pubkey: &PublicKey
) -> Result<(), Error>

Verify a Schnorr signature.

pub fn generate_schnorrsig_keypair<R>(
    &self,
    rng: &mut R
) -> (KeyPair, PublicKey) where
    R: Rng + ?Sized, 

Generates a random Schnorr KeyPair and its associated Schnorr PublicKey. Convenience function for schnorrsig::KeyPair::new and schnorrsig::PublicKey::from_keypair; call those functions directly for batch key generation. Requires a signing-capable context. Requires compilation with the “rand” feature.

impl<C> Secp256k1<C> where
    C: Context, 

pub fn ctx(&self) -> &*mut Context

Getter for the raw pointer to the underlying secp256k1 context. This shouldn’t be needed with normal usage of the library. It enables extending the Secp256k1 with more cryptographic algorithms outside of this crate.

pub fn preallocate_size_gen() -> usize

Returns the required memory for a preallocated context buffer in a generic manner(sign/verify/all)

pub fn randomize<R>(&mut self, rng: &mut R) where
    R: Rng + ?Sized, 

(Re)randomizes the Secp256k1 context for cheap sidechannel resistance; see comment in libsecp256k1 commit d2275795f by Gregory Maxwell. Requires compilation with “rand” feature.

pub fn seeded_randomize(&mut self, seed: &[u8; 32])

(Re)randomizes the Secp256k1 context for cheap sidechannel resistance given 32 bytes of cryptographically-secure random data; see comment in libsecp256k1 commit d2275795f by Gregory Maxwell.

impl<C> Secp256k1<C> where
    C: Signing, 

pub fn sign(&self, msg: &Message, sk: &SecretKey) -> Signature

Constructs a signature for msg using the secret key sk and RFC6979 nonce Requires a signing-capable context.

pub fn sign_grind_r(
    &self,
    msg: &Message,
    sk: &SecretKey,
    bytes_to_grind: usize
) -> Signature

Constructs a signature for msg using the secret key sk, RFC6979 nonce and “grinds” the nonce by passing extra entropy if necessary to produce a signature that is less than 71 - bytes_to_grund bytes. The number of signing operation performed by this function is exponential in the number of bytes grinded. Requires a signing capable context.

pub fn sign_low_r(&self, msg: &Message, sk: &SecretKey) -> Signature

Constructs a signature for msg using the secret key sk, RFC6979 nonce and “grinds” the nonce by passing extra entropy if necessary to produce a signature that is less than 71 bytes and compatible with the low r signature implementation of bitcoin core. In average, this function will perform two signing operations. Requires a signing capable context.

pub fn generate_keypair<R>(&self, rng: &mut R) -> (SecretKey, PublicKey) where
    R: Rng + ?Sized, 

Generates a random keypair. Convenience function for key::SecretKey::new and key::PublicKey::from_secret_key; call those functions directly for batch key generation. Requires a signing-capable context. Requires compilation with the “rand” feature.

impl<C> Secp256k1<C> where
    C: Verification, 

pub fn verify(
    &self,
    msg: &Message,
    sig: &Signature,
    pk: &PublicKey
) -> Result<(), Error>

Checks that sig is a valid ECDSA signature for msg using the public key pubkey. Returns Ok(()) on success. Note that this function cannot be used for Bitcoin consensus checking since there may exist signatures which OpenSSL would verify but not libsecp256k1, or vice-versa. Requires a verify-capable context.

let message = Message::from_slice(&[0xab; 32]).expect("32 bytes");
let sig = secp.sign(&message, &secret_key);
assert_eq!(secp.verify(&message, &sig, &public_key), Ok(()));

let message = Message::from_slice(&[0xcd; 32]).expect("32 bytes");
assert_eq!(secp.verify(&message, &sig, &public_key), Err(Error::IncorrectSignature));

Trait Implementations

impl<C> Clone for Secp256k1<C> where
    C: Context, 

pub fn clone(&self) -> Secp256k1<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Secp256k1<C> where
    C: Context, 

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

Formats the value using the given formatter.

impl Default for Secp256k1<All>

pub fn default() -> Secp256k1<All>

Returns the “default value” for a type.

impl<C> Drop for Secp256k1<C> where
    C: Context, 

pub fn drop(&mut self)

Executes the destructor for this type.

impl FlowSigner for Secp256k1<SignOnly>

type Algorithm = Secp256k1

The algorithm of this signer.

type PublicKey = PublicKey

The public key used by this signer.

type SecretKey = SecretKey

The secret key used by this signer.

type Signature = Signature

The signature type produced by this signer.

fn new() -> Self

Creates a new signer.

fn sign_populated(
    &self,
    hashed: [u8; 32],
    secret_key: &Self::SecretKey
) -> Self::Signature

Signs a 256 bit hashed data with the secret key.

fn to_public_key(&self, secret_key: &Self::SecretKey) -> Self::PublicKey

Converts a secret key to its public counterpart.

fn serialize_public_key(&self, public_key: &Self::PublicKey) -> [u8; 64]

Serializes a public key. Excluding the leading 0x04.

fn sign(
    &self,
    hasher: impl FlowHasher,
    secret_key: &Self::SecretKey
) -> Self::Signature

Creates a signature by consuming a populated hasher and a secret key.

impl<C> PartialEq<Secp256k1<C>> for Secp256k1<C> where
    C: Context, 

pub fn eq(&self, _other: &Secp256k1<C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<C> Eq for Secp256k1<C> where
    C: Context, 

impl<C> Send for Secp256k1<C> where
    C: Context, 

impl<C> Sync for Secp256k1<C> where
    C: Context,