Remove script_lines (BitVM#281)

Author: Hakkush-07

bitvm/src/bn254/fq6.rs

@@ -157,58 +157,54 @@ impl Fq6 {
         let (hinted_script4, hints4) = Fq2::hinted_mul(2, a.c1, 0, a.c2);
         let (hinted_script5, hints5) = Fq2::hinted_square(a.c2);
 
-        let mut script = script! {};
-        let script_lines = [
+        let script = script! {
             // compute s_0 = a_0 ^ 2
-            Fq2::copy(4),
-            hinted_script1,
+            { Fq2::copy(4) }
+            { hinted_script1 }
             // compute a_0 + a_2
-            Fq2::roll(6),
-            Fq2::copy(4),
-            Fq2::add(2, 0),
+            { Fq2::roll(6) }
+            { Fq2::copy(4) }
+            { Fq2::add(2, 0) }
             // compute s_1 = (a_0 + a_1 + a_2) ^ 2
-            Fq2::copy(0),
-            Fq2::copy(8),
-            Fq2::add(2, 0),
-            hinted_script2,
+            { Fq2::copy(0) }
+            { Fq2::copy(8) }
+            { Fq2::add(2, 0) }
+            { hinted_script2 }
             // compute s_2 = (a_0 - a_1 + a_2) ^ 2
-            Fq2::copy(8),
-            Fq2::sub(4, 0),
-            hinted_script3,
+            { Fq2::copy(8) }
+            { Fq2::sub(4, 0) }
+            { hinted_script3 }
             // compute s_3 = 2a_1a_2
-            Fq2::roll(8),
-            Fq2::copy(8),
-            hinted_script4,
-            Fq2::double(0),
+            { Fq2::roll(8) }
+            { Fq2::copy(8) }
+            { hinted_script4 }
+            { Fq2::double(0) }
             // compute s_4 = a_2 ^ 2
-            Fq2::roll(8),
-            hinted_script5,
+            { Fq2::roll(8) }
+            { hinted_script5 }
             // compute t_1 = (s_1 + s_2) / 2
-            Fq2::copy(6),
-            Fq2::roll(6),
-            Fq2::add(2, 0),
-            Fq2::div2(),
+            { Fq2::copy(6) }
+            { Fq2::roll(6) }
+            { Fq2::add(2, 0) }
+            { Fq2::div2() }
             // at this point, we have s_0, s_1, s_3, s_4, t_1
 
             // compute c_0 = s_0 + \beta s_3
-            Fq2::copy(4),
-            Fq6::mul_fq2_by_nonresidue(),
-            Fq2::copy(10),
-            Fq2::add(2, 0),
+            { Fq2::copy(4) }
+            { Fq6::mul_fq2_by_nonresidue() }
+            { Fq2::copy(10) }
+            { Fq2::add(2, 0) }
             // compute c_1 = s_1 - s_3 - t_1 + \beta s_4
-            Fq2::copy(4),
-            Fq6::mul_fq2_by_nonresidue(),
-            Fq2::copy(4),
-            Fq2::add(10, 0),
-            Fq2::sub(10, 0),
-            Fq2::add(2, 0),
+            { Fq2::copy(4) }
+            { Fq6::mul_fq2_by_nonresidue() }
+            { Fq2::copy(4) }
+            { Fq2::add(10, 0) }
+            { Fq2::sub(10, 0) }
+            { Fq2::add(2, 0) }
             // compute c_2 = t_1 - s_0 - s_4
-            Fq2::add(8, 6),
-            Fq2::sub(6, 0),
-        ];
-        for script_line in script_lines {
-            script = script.push_script(script_line.compile());
-        }
+            { Fq2::add(8, 6) }
+            { Fq2::sub(6, 0) }
+        };
 
         hints.extend(hints1);
         hints.extend(hints2);

bitvm/src/signatures/winternitz.rs

@@ -389,19 +389,18 @@ impl Converter for ToBytesConverter {
         ps.byte_message_length()
     }
     fn get_script(ps: &Parameters) -> Script {
-        let mut turning_into_bytes = script! {};
         if ps.block_length == 8 {
             //already bytes
-            turning_into_bytes = script! {};
+            script! {}
         } else if ps.block_length == 4 {
-            turning_into_bytes = script! {
+            script! {
                 for i in 0..ps.message_length / 2 {
                     OP_SWAP
                     for _ in 0..ps.block_length {
                         OP_DUP OP_ADD
                     }
                     OP_ADD
-                    if i != (ps.message_length/2) - 1 {
+                    if i != (ps.message_length / 2) - 1 {
                         OP_TOALTSTACK
                     }
                 }
@@ -410,23 +409,43 @@ impl Converter for ToBytesConverter {
                         OP_FROMALTSTACK
                     }
                 }
-            };
+            }
         } else {
             let mut lens: Vec<u32> = vec![];
-            let mut script_lines: Vec<Script> = vec![];
+            let mut split_save = vec![];
             for i in 0..ps.message_length {
                 let start = i * ps.block_length;
                 let next_stop = start + 8 - (start % 8);
                 let split = next_stop - start;
+                split_save.push(split);
                 if split >= ps.block_length {
                     lens.push(ps.block_length);
-                    script_lines.push(script! {
-                        OP_TOALTSTACK
-                    });
                 } else {
                     lens.push(split);
                     lens.push(ps.block_length - split);
-                    script_lines.push(script! {
+                }
+            }
+            lens.reverse();
+            let mut last_bytes_var = (8 - (ps.message_length * ps.block_length % 8)) % 8;
+            let mut is_last_zero_var = true;
+            let mut last_bytes_save = vec![];
+            let mut is_last_zero_save = vec![];
+            for l in lens.clone() {
+                last_bytes_save.push(last_bytes_var);
+                if last_bytes_var >= 8 {
+                    last_bytes_var = 0;
+                    is_last_zero_var = true;
+                }
+                is_last_zero_save.push(is_last_zero_var);
+                is_last_zero_var = false;
+                last_bytes_var += l;
+            }
+
+            script! {
+                for split in split_save {
+                    if split >= ps.block_length {
+                        OP_TOALTSTACK
+                    } else {
                         OP_0
                         for j in (split..ps.block_length).rev() {
                             if j != ps.block_length - 1 {
@@ -449,43 +468,22 @@ impl Converter for ToBytesConverter {
                         OP_SWAP
                         OP_TOALTSTACK
                         OP_TOALTSTACK
-                    });
+                    }
                 }
-            }
-            lens.reverse();
-            let mut last_bytes = (8 - (ps.message_length * ps.block_length % 8)) % 8;
-            let mut is_last_zero = true;
-            script_lines.push(script! {
                 OP_0
-            });
-            for l in lens {
-                if last_bytes >= 8 {
-                    last_bytes = 0;
-                    script_lines.push(script! {
+                for (l, (last_bytes, is_last_zero)) in lens.into_iter().zip(last_bytes_save.into_iter().zip(is_last_zero_save.into_iter())) {
+                    if last_bytes >= 8 {
                         OP_0
-                    });
-                    is_last_zero = true;
-                }
-                if !is_last_zero {
-                    script_lines.push(script! {
+                    }
+                    if !is_last_zero {
                         for _ in 0..l {
                             OP_DUP OP_ADD
                         }
-                    });
+                    }
+                    OP_FROMALTSTACK OP_ADD
                 }
-                is_last_zero = false;
-                script_lines.push(script! {
-                    OP_FROMALTSTACK
-                    OP_ADD
-                });
-                last_bytes += l;
-            }
-
-            for script_line in script_lines {
-                turning_into_bytes = turning_into_bytes.push_script(script_line.compile());
             }
         }
-        turning_into_bytes
     }
 }