Function hash_messages

bitvm/src/chunk/wrap_hasher.rs:190–281

This function is used to add hashing layer to the disprove script. The additional logic here is due to a constraint in blake3_u4 which requires the entire stack to only hold the message to be hashed. Given an array of Elements of different ElementType, the function assumes the order [Input_A_Preimage, Input_B_Preimage, Output_Preimage, should_do_output_validity_check_bit] for main stack and [Outpu

(elem_types: Vec<ElementType>)

// should be done. This is used in the context where tapscript is disproven based on input invalidity indifferent to output.
// i.e. if the claimed input is invalid, user can disprove indifferent to output computation
pub fn hash_messages(elem_types: Vec<ElementType>) -> Script {
    // Altstack: [Hc, Hb, Ha]
    // Stack: [a, b, c, should_do_output_validity_check_bit]
    let elem_types: Vec<ElementType> = elem_types
        .into_iter()
        .filter(|et| et.number_of_limbs_of_hashing_preimage() > 0)
        .collect();
    let mut loop_script = script! {};

    for msg_index in 0..elem_types.len() {
        let mut remaining = elem_types[msg_index + 1..].to_vec(); // "remaining" refers to elements other than the msg to hash
        let mut from_altstack = script! {}; // script to bring "remaining" elements back from altstack
        for elem_type in &remaining {
            from_altstack = script! {
                {from_altstack}
                // bring "size" number of elements from altstack; where "size" is the number of limbs of elem_type
                for _ in 0..elem_type.number_of_limbs_of_hashing_preimage() {
                    {Fq::fromaltstack()}
                }
            };
        }
        remaining.reverse();
        let mut to_altstack = script! {}; // script to send "remaining" elements to altstack
        for elem_type in &remaining {
            to_altstack = script! {
                {to_altstack}
                for _ in 0..elem_type.number_of_limbs_of_hashing_preimage() {
                    {Fq::toaltstack()}
                }
            };
        }

        // hash remaining element
        let elem_type = elem_types[msg_index];
        let hash_scr = script! {
            if elem_type == ElementType::Fp6 {
                {hash_fp6()}
            } else if elem_type == ElementType::G1 {
                {hash_fp2()}
            } else if elem_type == ElementType::G2EvalPoint {
                {hash_g2acc_with_hashed_le()}
            } else if elem_type == ElementType::G2EvalMul {
                {hash_g2acc_with_hash_t()}
            } else if elem_type == ElementType::G2Eval {
                {hash_g2acc()}
            }
        };

        let verify_scr = script! {
            // bottom of the stack contains the calculated hash, bring it to the top
            for _ in 0..Fq::N_LIMBS {
                OP_DEPTH OP_1SUB OP_ROLL
            }
            // top of altstack contains the claimed hash for corresponding message
            {Fq::fromaltstack()}
            // compare hashes
            {Fq::equal(1, 0)}
            if msg_index == elem_types.len()-1 { // if last message