Interface CompactWots

bitvm/src/signatures/public.rs:219–321

High-level functionality for working with compact Winternitz signatures. Compact signatures contain the signature of each digit, but not the digit itself. ## See [`Wots`]

///
/// [`Wots`]
pub trait CompactWots: Wots {
    type CompactSignature: AsRef<[[u8; 20]]> + TryFrom<Vec<[u8; 20]>, Error: std::fmt::Debug>;
    const COMPACT_ALGORITHM: Winternitz<BruteforceVerifier, Self::Converter> = Winternitz::new();

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

    /// Generates a compact signature for the given `secret_key` and `message`.
    fn compact_sign(
        secret_key: &WinternitzSecret,
        message: &Self::Message,
    ) -> Self::CompactSignature {
        let witness = Self::compact_sign_to_raw_witness(secret_key, message);
        Self::compact_raw_witness_to_signature(&witness)
    }

    /// Parses the given bitcoin `witness` as a Winternitz signature.
    ///
    /// The `witness` must be in the format that is returned by [`CompactWots::compact_sign`].
    ///
    /// ## Panics
    ///
    /// This method panics if the `witness` is ill-formatted.
    fn compact_raw_witness_to_signature(witness: &bitcoin::Witness) -> Self::CompactSignature {
        assert_eq!(witness.len(), Self::TOTAL_DIGIT_LEN as usize);
        let mut digit_signatures: Vec<[u8; 20]> =
            Vec::with_capacity(Self::TOTAL_DIGIT_LEN as usize);

        for i in 0..witness.len() {
            assert_eq!(
                witness[i].len(),
                20,
                "the digit signature should be constant 20 bytes"
            );

            let digit_signature: [u8; 20] = witness[i].try_into().unwrap();
            digit_signatures.push(digit_signature);
        }

        debug_assert_eq!(digit_signatures.len(), Self::TOTAL_DIGIT_LEN as usize);
        match Self::CompactSignature::try_from(digit_signatures) {
            Ok(signature) => signature,
            _ => unreachable!(),
        }
    }

    /// Encodes the given Winternitz `signature` as a bitcoin witness.
    fn compact_signature_to_raw_witness(signature: &Self::CompactSignature) -> bitcoin::Witness {
        let mut witness = bitcoin::Witness::new();