Interface Wots

bitvm/src/signatures/public.rs:41–210

High-level functionality for working with Winternitz signatures. Signatures contain the signature of each digit as well as the digit itself. ## See [`CompactWots`]

///
/// [`CompactWots`]
pub trait Wots {
    type Converter: Converter;
    type PublicKey: AsRef<[[u8; 20]]> + TryFrom<Vec<[u8; 20]>, Error: std::fmt::Debug>;
    type Message: AsRef<[u8]> + TryFrom<Vec<u8>, Error: std::fmt::Debug>;
    type Signature: AsRef<[[u8; 21]]> + TryFrom<Vec<[u8; 21]>, Error: std::fmt::Debug>;

    const ALGORITHM: Winternitz<ListpickVerifier, Self::Converter> = Winternitz::new();
    const MSG_BYTE_LEN: u32;
    const PARAMETERS: Parameters = Parameters::new_by_bit_length(Self::MSG_BYTE_LEN * 8, LOG2_BASE);
    const TOTAL_DIGIT_LEN: u32 = Self::PARAMETERS.total_digit_len();

    /// Generates a random secret key.
    fn generate_secret_key() -> WinternitzSecret {
        let mut buffer = [0u8; 20];
        let mut rng = rand::rngs::OsRng;
        rand::RngCore::fill_bytes(&mut rng, &mut buffer);
        Vec::from(buffer)
    }

    /// Creates a secret key from the given `secret` string.
    ///
    /// ## Warning
    ///
    /// For backwards compatibility, the original conversion function is used.
    /// The `secret` string is converted into ASCII bytes,
    /// which are in turn converted into lower hex ASCII bytes.
    #[deprecated(note = "It is safer to use Vec<u8> directly")]
    fn secret_from_str(secret: &str) -> WinternitzSecret {
        secret.as_bytes().to_lower_hex_string().into_bytes()
    }

    /// Generates a public key for the given `secret_key`.
    fn generate_public_key(secret_key: &WinternitzSecret) -> Self::PublicKey {
        let pubkey_vec = winternitz::generate_public_key(&Self::PARAMETERS, secret_key);
        match Self::PublicKey::try_from(pubkey_vec) {
            Ok(public_key) => public_key,
            _ => unreachable!(),
        }
    }

    /// Generates a signature for the given `secret_key` and `message`,
    /// in form of a Bitcoin witness.
    fn sign_to_raw_witness(
        secret_key: &WinternitzSecret,
        message: &Self::Message,
    ) -> bitcoin::Witness {
        let witness = Self::ALGORITHM.sign(&Self::PARAMETERS, secret_key, message.as_ref());
        debug_assert_eq!(witness.len(), 2 * Self::TOTAL_DIGIT_LEN as usize);
        witness
    }

    /// Generates a signature for the given `secret_key` and `message`.
    fn sign(secret_key: &WinternitzSecret, message: &Self::Message) -> Self::Signature {
        let witness = Self::sign_to_raw_witness(secret_key, message);
        Self::raw_witness_to_signature(&witness)
    }

    /// Generates a signature for the given `inputs`.