Function sha256

bitvm/src/hash/sha256_u4.rs:260–467

(num_bytes: u32)

}

pub fn sha256(num_bytes: u32) -> Script {
    // up to 55 is one block and always supports add table
    // probably up to 68 bytes I can afford to load the add tables for the first chunk (but have I would have to unload it)

    let (mut padding_scripts, chunks) = double_padding(num_bytes);
    let mut bytes_per_chunk: Vec<u32> = Vec::new();
    let mut bytes_remaining = num_bytes;
    while bytes_remaining > 0 {
        if bytes_remaining > 64 {
            bytes_per_chunk.push(64);
            bytes_remaining -= 64;
        } else {
            bytes_per_chunk.push(bytes_remaining);
            bytes_remaining = 0;
        }
    }
    if bytes_per_chunk.len() < chunks as usize {
        bytes_per_chunk.push(0);
    }
    println!("{:?}", bytes_per_chunk);
    println!("{:?}", padding_scripts);

    let add_size = 128;
    let sched_size = 128;
    let rrot_size = 16 * 5;
    let half_logic_size = 136 + 16;
    let mut tables_size = rrot_size + half_logic_size;
    let use_add_table = chunks == 1;
    if use_add_table {
        tables_size += add_size;
    }

    let sched_loop_offset_and = sched_size;
    let sched_loop_offset_rrot = sched_loop_offset_and + half_logic_size;
    let sched_loop_offset_add = sched_loop_offset_rrot + rrot_size;

    let full_sched_size = 512;
    let temp_vars_size = 8 * 8;

    let vars_top = temp_vars_size + full_sched_size;
    let main_loop_offset_and = vars_top;
    let main_loop_offset_rrot = main_loop_offset_and + half_logic_size;
    let main_loop_offset_add = main_loop_offset_rrot + rrot_size;

    script! {

        if use_add_table {
            { u4_push_add_tables() }
        }
        { u4_push_rrot_tables() }     // rshiftn 16*6= 96
        { u4_push_half_xor_table() }  // 136
        { u4_push_half_lookup() }     // 16
                                      // total :  136 + 16 + 96 = 248

        for c in 0..chunks {

            if c > 0 {
                //change and with xor