Struct Secp256k1KeyPair 

pub struct Secp256k1KeyPair { /* private fields */ }

secp256k1 key pair for Ethereum, Bitcoin, Tron, and Ripple.

This key pair uses the secp256k1 elliptic curve, which is the standard for most major blockchain networks.

Security

• The signing key is stored securely and is ZeroizeOnDrop
• Signatures are normalized to prevent malleability
• Recovery IDs are computed for Ethereum compatibility

Example

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

// Generate a new key pair
let keypair = Secp256k1KeyPair::generate();

// Or create from existing bytes
let secret_bytes = [0x42u8; 32]; // Use real secret in production!
let keypair = Secp256k1KeyPair::from_bytes(secret_bytes)
    .expect("valid secret key");

// Sign a message hash
let hash = [0u8; 32]; // Use real hash in production!
let signature = keypair.sign(&hash).expect("signing succeeded");

// Get Ethereum address
let address = keypair.public_key().ethereum_address();
println!("Address: 0x{}", hex::encode(address));

Implementations

impl Secp256k1KeyPair

pub fn from_secret_key(secret: &SecretKey) -> Result<Self, SignError>

Create a key pair from a SecretKey.

This consumes the SecretKey to ensure the key material exists in only one place.

Errors

Returns an error if the secret key bytes are not a valid secp256k1 scalar (e.g., zero or greater than the curve order).

Example

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

let secret = SecretKey::generate();
let keypair = Secp256k1KeyPair::from_secret_key(&secret)
    .expect("valid secret key");

pub fn verify(&self, hash: &[u8; 32], signature: &Secp256k1Signature) -> bool

Verify a signature against a hash using this key pair’s public key.

This is primarily useful for testing. In production, verification is typically done using the public key alone.

Arguments

• hash - The 32-byte hash that was signed
• signature - The signature to verify

Returns

true if the signature is valid, false otherwise.

Trait Implementations

impl Debug for Secp256k1KeyPair

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

Formats the value using the given formatter.

impl KeyPair for Secp256k1KeyPair

type Signature = Secp256k1Signature

The signature type produced by this key pair.

type PublicKey = Secp256k1PublicKey

The public key type for this key pair.

fn generate() -> Self

Generate a new random key pair.

fn from_bytes(bytes: [u8; 32]) -> Result<Self, SignError>

Create a key pair from raw secret key bytes.

fn public_key(&self) -> &Self::PublicKey

Get the public key.

fn sign(&self, hash: &[u8; 32]) -> Result<Self::Signature, SignError>

Sign a 32-byte message hash.