Struct Secp256k1Signature 

pub struct Secp256k1Signature { /* private fields */ }

Wrapper for secp256k1 ECDSA signatures.

Contains the 64-byte signature (r || s) and the recovery ID for Ethereum compatibility.

Signature Formats

• Standard: 64 bytes (r: 32 bytes || s: 32 bytes)
• Recoverable: 65 bytes (r || s || v) where v is the recovery ID

Security

The S value is normalized to the lower half of the curve order to prevent signature malleability attacks.

Example

use txgate_crypto::keypair::{KeyPair, Secp256k1KeyPair};

let keypair = Secp256k1KeyPair::generate();
let hash = [0u8; 32];
let signature = keypair.sign(&hash).expect("signing failed");

// Get standard 64-byte signature
assert_eq!(signature.as_ref().len(), 64);

// Get recoverable signature with recovery ID
let recoverable = signature.to_recoverable_bytes();
assert_eq!(recoverable.len(), 65);

// Get recovery ID for ecrecover
let v = signature.recovery_id();
assert!(v == 0 || v == 1);

Implementations

impl Secp256k1Signature

pub const fn from_bytes_and_recovery_id( bytes: [u8; 64], recovery_id: u8, ) -> Self

Create a signature from raw bytes and a recovery ID.

This is useful for reconstructing a signature from its components.

Arguments

• bytes - The 64-byte signature (r || s)
• recovery_id - The recovery ID (0 or 1)

Example

use txgate_crypto::keypair::{KeyPair, Secp256k1KeyPair, Secp256k1Signature};

let keypair = Secp256k1KeyPair::generate();
let hash = [0u8; 32];
let signature = keypair.sign(&hash).expect("signing failed");

// Get the recoverable bytes
let recoverable = signature.to_recoverable_bytes();

// Reconstruct the signature
let bytes: [u8; 64] = recoverable[..64].try_into().unwrap();
let recovery_id = recoverable[64];
let reconstructed = Secp256k1Signature::from_bytes_and_recovery_id(bytes, recovery_id);

assert_eq!(signature.as_ref(), reconstructed.as_ref());

pub const fn recovery_id(&self) -> u8

Get the recovery ID.

This is 0 or 1, which can be used with Ethereum’s ecrecover:

• For EIP-155 transactions: v = recovery_id + 27
• For EIP-2930/EIP-1559: v = recovery_id

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

Return signature as 65 bytes: r (32) || s (32) || v (1).

The v byte is the raw recovery ID (0 or 1). For Ethereum transactions, you may need to add 27 or use chain-specific calculations for EIP-155.

pub fn r(&self) -> &[u8; 32]

Get the r component of the signature (first 32 bytes).

This always succeeds because the signature is always exactly 64 bytes.

Panics

This method cannot panic in practice because the internal storage is always exactly 64 bytes, but the conversion is technically fallible.

pub fn s(&self) -> &[u8; 32]

Get the s component of the signature (last 32 bytes).

This always succeeds because the signature is always exactly 64 bytes.

Panics

This method cannot panic in practice because the internal storage is always exactly 64 bytes, but the conversion is technically fallible.

Trait Implementations

impl AsRef<[u8]> for Secp256k1Signature

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

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Secp256k1Signature

fn clone(&self) -> Secp256k1Signature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Secp256k1Signature

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

Formats the value using the given formatter.