Struct Nonce 

pub struct Nonce { /* private fields */ }

A verifier-chosen nonce for an ownership proof (Operation D).

32 opaque bytes the verifier sends to the prover so the resulting OwnershipProof is bound to a fresh, single-use challenge and cannot be replayed. Generate one with crate::generate_nonce.

Unlike the key types, a nonce has no validity constraint — any 32 bytes are a valid nonce — so Nonce::from_bytes is infallible. The prefixed form (nonce_<hex>_<checksum>) is, exactly like the other types, a pure transport wrapper: the bytes that get hashed into a proof are the raw Nonce::as_bytes, never the prefixed string. Both prover and verifier must use the same nonce.

Implementations

impl Nonce

pub fn from_bytes(bytes: [u8; 32]) -> Self

Wrap 32 raw bytes as a nonce. Infallible — any value is valid.

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

The raw 32 bytes. These are what an ownership proof binds to (pass them as the context argument of crate::prove_ownership / crate::verify_ownership).

pub fn as_bytes(&self) -> &[u8]

Borrow the raw bytes, e.g. to pass straight as context.

pub fn to_hex(&self) -> String

Hex-encode using lowercase digits (64 characters).

pub fn from_hex(s: &str) -> Result<Self>

Decode from a 64-character hex string.

pub fn to_prefixed(&self) -> String

Encode in the human-friendly prefixed format: nonce_<hex>_<checksum>.

pub fn from_prefixed(s: &str) -> Result<Self>

Decode a nonce_<hex>_<checksum> string produced by Nonce::to_prefixed, verifying the tag and the checksum.

Trait Implementations

impl Clone for Nonce

fn clone(&self) -> Nonce

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Nonce

impl Debug for Nonce

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

Formats the value using the given formatter.

impl Eq for Nonce

impl PartialEq for Nonce

fn eq(&self, other: &Nonce) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Nonce