Struct Schnorr 

pub struct Schnorr<H: Hashable> {
    pub hasher: Box<dyn Hasher<Message<H>>>,
    pub domain_param: H::D,
}

Schnorr signer context for the Mina signature algorithm

For details about the signature algorithm please see the schnorr documentation

Fields

hasher: Box<dyn Hasher<Message<H>>>

The hasher instance used to hash messages

domain_param: H::D

The domain parameter used for hashing

Implementations

impl<H: 'static + Hashable> Schnorr<H>

pub fn derive_nonce_compatible(&self, kp: &Keypair, input: &H) -> ScalarField

Derives a nonce compatible with OCaml/TypeScript implementations

This function implements the deterministic nonce derivation algorithm as specified in the Mina signature specification: https://github.com/MinaProtocol/mina/blob/develop/docs/specs/signatures/description.md

Compatibility

This implementation is compatible with the TypeScript version: https://github.com/o1-labs/o1js/blob/main/src/mina-signer/src/signature.ts#L128

The private key conversion replicates the “Field.project” method with unpack from the OCaml implementation, which performs modular reduction when the scalar field value is larger than the base field modulus.

Algorithm

The nonce derivation follows this process:

1. Create ROInput from: message || public_key_x || public_key_y || private_key || network_id
2. Pack the ROInput into fields using Mina’s field packing
3. Convert packed fields to bits (255 bits per field)
4. Convert bits to bytes for BLAKE2b input
5. Hash with BLAKE2b-256
6. Drop the top 2 bits to create a valid scalar field element

Parameters

• kp - The keypair containing both public and private keys
• input - The message to be signed

Returns

A deterministic nonce as a scalar field element, ensuring compatibility with OCaml and TypeScript signature implementations.

Test Vectors

For test vectors demonstrating this function’s usage, see the sign_fields_test in tests/signer.rs which uses the compatible nonce derivation mode (packed: true).

Security

This function generates a cryptographically secure, deterministic nonce that:

• Depends on the private key, public key, message, and network context
• Ensures no two different messages share the same nonce (with the same key)
• Is compatible with existing Mina protocol implementations

Trait Implementations

impl<H: 'static + Hashable> Signer<H> for Schnorr<H>

fn sign(&mut self, kp: &Keypair, input: &H, packed: bool) -> Signature

Sign input (see [Hashable]) using keypair kp and return the corresponding signature.

fn verify(&mut self, sig: &Signature, public: &PubKey, input: &H) -> bool

Verify that the signature sig on input (see [Hashable]) is signed with the secret key corresponding to pub_key. Return true if the signature is valid and false otherwise.