Clean up code and fix styles

ZeroSync · Aug 16, 2023 · 272cc76 · 272cc76
1 parent 36ff8a9
commit 272cc76
Show file tree

Hide file tree

Showing 7 changed files with 114 additions and 120 deletions.
diff --git a/program/src/aggregate_proofs.cairo b/program/src/aggregate_proofs.cairo
@@ -69,7 +69,7 @@ func main{
 
     // Ensure the program is either the batch program or the aggregate program
     if (next_program_hash != BATCH_PROGRAM_HASH) {
-        assert next_program_hash = AGGREGATE_PROGRAM_HASH;
+        assert AGGREGATE_PROGRAM_HASH = next_program_hash;
         assert next_mem_values[PROGRAM_HASH_INDEX] = AGGREGATE_PROGRAM_HASH;
     } else {
         %{ print("This is a batch proof") %}

diff --git a/program/src/block_header/block_header.cairo b/program/src/block_header/block_header.cairo
@@ -118,7 +118,7 @@ func bits_to_target{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(bits) -> felt
     // Then, using a bitwise AND to get only the first 8 bits.
     let (bits_to_shift) = bitwise_and(bits, MASK_BITS_TO_SHIFT);
     // And finally, do the shifts
-    let exponent = bits_to_shift / 0x1000000;
+    tempvar exponent = bits_to_shift / 0x1000000;
 
     // Extract the last 3 bytes from `bits` to get the significand
     let (significand) = bitwise_and(bits, 0x00ffffff);
@@ -127,14 +127,14 @@ func bits_to_target{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(bits) -> felt
     // when the exponent is greater than 3.
     // And it is `significand` shifted `exponent` times to the right when
     // it is less than 3.
-    let is_greater_than_2 = (2 - exponent) * (1 - exponent) * exponent;
+    tempvar is_greater_than_2 = (2 - exponent) * (1 - exponent) * exponent;
     if (is_greater_than_2 == 0) {
         let shift = pow2(8 * (3 - exponent));
         let (target, _rem) = unsigned_div_rem(significand, shift);
         return target;
     } else {
         let shift = pow2(8 * (exponent - 3));
-        let target = significand * shift;
+        tempvar target = significand * shift;
         return target;
     }
 }

diff --git a/program/src/block_header/median.cairo b/program/src/block_header/median.cairo
@@ -34,18 +34,19 @@ func verify_timestamps_median{range_check_ptr}(timestamp_array: felt*, median) {
     tempvar range_check_ptr = range_check_ptr;
 
     verify_median_loop:
-    let delta_sign = sign([timestamp_ptr] - median);
-    if (delta_sign == 0) {
-        tempvar signs_diff = signs_diff;
-        tempvar n_median_occurences = n_median_occurences + 1;
-    } else {
-        tempvar signs_diff = signs_diff + delta_sign;
-        tempvar n_median_occurences = n_median_occurences;
-    }
-    tempvar timestamp_ptr = timestamp_ptr + 1;
-    tempvar n_timestamps = n_timestamps - 1;
-    tempvar range_check_ptr = range_check_ptr;
-    jmp verify_median_loop if n_timestamps != 0;
+        let delta_sign = sign([timestamp_ptr] - median);
+        if (delta_sign == 0) {
+            tempvar signs_diff = signs_diff;
+            tempvar n_median_occurences = n_median_occurences + 1;
+        } else {
+            tempvar signs_diff = signs_diff + delta_sign;
+            tempvar n_median_occurences = n_median_occurences;
+        }
+        tempvar timestamp_ptr = timestamp_ptr + 1;
+        tempvar n_timestamps = n_timestamps - 1;
+        tempvar range_check_ptr = range_check_ptr;
+        jmp verify_median_loop if n_timestamps != 0;
+
     let absolute_signs = abs_value(signs_diff);
     with_attr error_message("invalid timestamps median") {
         assert_le(absolute_signs + 1, n_median_occurences);

diff --git a/program/src/crypto/hash256.cairo b/program/src/crypto/hash256.cairo
@@ -1,12 +1,8 @@
-
 from starkware.cairo.common.cairo_builtins import BitwiseBuiltin
-
 from starkware.cairo.common.alloc import alloc
 from starkware.cairo.common.registers import get_fp_and_pc
-
 from starkware.cairo.common.memcpy import memcpy
 from starkware.cairo.common.memset import memset
-
 from starkware.cairo.common.math import unsigned_div_rem
 
 from utils.utils import UINT32_SIZE
@@ -71,7 +67,6 @@ func hash256_block_header{range_check_ptr, hash256_ptr: felt*}(block_header: fel
     return hash256;
 }
 
-// NOTE: what about {message_schedule_ptr: felt*} ?
 
 func _finalize_hash256_inner{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(hash256_ptr: felt*, n: felt, initial_state: felt*, round_constants: felt*) {
     if (n == 0) {
@@ -94,35 +89,35 @@ func _finalize_hash256_inner{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(hash
     tempvar m = SHA256_CHUNK_FELT_SIZE;
 
     message_loop:
-    tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 0] = x0;
-    assert [range_check_ptr + 1] = MAX_VALUE - x0;
-    tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 2] = x1;
-    assert [range_check_ptr + 3] = MAX_VALUE - x1;
-    tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 4] = x2;
-    assert [range_check_ptr + 5] = MAX_VALUE - x2;
-    tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 6] = x3;
-    assert [range_check_ptr + 7] = MAX_VALUE - x3;
-    tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 8] = x4;
-    assert [range_check_ptr + 9] = MAX_VALUE - x4;
-    tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 10] = x5;
-    assert [range_check_ptr + 11] = MAX_VALUE - x5;
-    tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 12] = x6;
-    assert [range_check_ptr + 13] = MAX_VALUE - x6;
-    assert [message] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
-                            2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
-
-    tempvar message = message + 1;
-    tempvar hash256_ptr = hash256_ptr + 1;
-    tempvar range_check_ptr = range_check_ptr + 14;
-    tempvar m = m - 1;
-    jmp message_loop if m != 0;
+        tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 0] = x0;
+        assert [range_check_ptr + 1] = MAX_VALUE - x0;
+        tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 2] = x1;
+        assert [range_check_ptr + 3] = MAX_VALUE - x1;
+        tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 4] = x2;
+        assert [range_check_ptr + 5] = MAX_VALUE - x2;
+        tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 6] = x3;
+        assert [range_check_ptr + 7] = MAX_VALUE - x3;
+        tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 8] = x4;
+        assert [range_check_ptr + 9] = MAX_VALUE - x4;
+        tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 10] = x5;
+        assert [range_check_ptr + 11] = MAX_VALUE - x5;
+        tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 12] = x6;
+        assert [range_check_ptr + 13] = MAX_VALUE - x6;
+        assert [message] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
+                                2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
+
+        tempvar message = message + 1;
+        tempvar hash256_ptr = hash256_ptr + 1;
+        tempvar range_check_ptr = range_check_ptr + 14;
+        tempvar m = m - 1;
+        jmp message_loop if m != 0;
 
     // Run hash256 on the 7 instances.
 
@@ -143,35 +138,35 @@ func _finalize_hash256_inner{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(hash
     tempvar m = SHA256_CHUNK_FELT_SIZE;
 
     message_loop_2:
-    tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 0] = x0;
-    assert [range_check_ptr + 1] = MAX_VALUE - x0;
-    tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 2] = x1;
-    assert [range_check_ptr + 3] = MAX_VALUE - x1;
-    tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 4] = x2;
-    assert [range_check_ptr + 5] = MAX_VALUE - x2;
-    tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 6] = x3;
-    assert [range_check_ptr + 7] = MAX_VALUE - x3;
-    tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 8] = x4;
-    assert [range_check_ptr + 9] = MAX_VALUE - x4;
-    tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 10] = x5;
-    assert [range_check_ptr + 11] = MAX_VALUE - x5;
-    tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 12] = x6;
-    assert [range_check_ptr + 13] = MAX_VALUE - x6;
-    assert [message] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
-                            2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
-
-    tempvar message = message + 1;
-    tempvar hash256_ptr = hash256_ptr + 1;
-    tempvar range_check_ptr = range_check_ptr + 14;
-    tempvar m = m - 1;
-    jmp message_loop_2 if m != 0;
+        tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 0] = x0;
+        assert [range_check_ptr + 1] = MAX_VALUE - x0;
+        tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 2] = x1;
+        assert [range_check_ptr + 3] = MAX_VALUE - x1;
+        tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 4] = x2;
+        assert [range_check_ptr + 5] = MAX_VALUE - x2;
+        tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 6] = x3;
+        assert [range_check_ptr + 7] = MAX_VALUE - x3;
+        tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 8] = x4;
+        assert [range_check_ptr + 9] = MAX_VALUE - x4;
+        tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 10] = x5;
+        assert [range_check_ptr + 11] = MAX_VALUE - x5;
+        tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 12] = x6;
+        assert [range_check_ptr + 13] = MAX_VALUE - x6;
+        assert [message] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
+                                2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
+
+        tempvar message = message + 1;
+        tempvar hash256_ptr = hash256_ptr + 1;
+        tempvar range_check_ptr = range_check_ptr + 14;
+        tempvar m = m - 1;
+        jmp message_loop_2 if m != 0;
 
     // Run hash256 on the 7 instances.
 
@@ -204,36 +199,36 @@ func _finalize_hash256_inner{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(hash
     tempvar m = Hash256.SIZE;
 
     output_loop:
-    tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr] = x0;
-    assert [range_check_ptr + 1] = MAX_VALUE - x0;
-    tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 2] = x1;
-    assert [range_check_ptr + 3] = MAX_VALUE - x1;
-    tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 4] = x2;
-    assert [range_check_ptr + 5] = MAX_VALUE - x2;
-    tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 6] = x3;
-    assert [range_check_ptr + 7] = MAX_VALUE - x3;
-    tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 8] = x4;
-    assert [range_check_ptr + 9] = MAX_VALUE - x4;
-    tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 10] = x5;
-    assert [range_check_ptr + 11] = MAX_VALUE - x5;
-    tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
-    assert [range_check_ptr + 12] = x6;
-    assert [range_check_ptr + 13] = MAX_VALUE - x6;
-
-    assert [outputs] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
-                            2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
-
-    tempvar outputs = outputs + 1;
-    tempvar hash256_ptr = hash256_ptr + 1;
-    tempvar range_check_ptr = range_check_ptr + 14;
-    tempvar m = m - 1;
-    jmp output_loop if m != 0;
+        tempvar x0 = hash256_ptr[0 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr] = x0;
+        assert [range_check_ptr + 1] = MAX_VALUE - x0;
+        tempvar x1 = hash256_ptr[1 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 2] = x1;
+        assert [range_check_ptr + 3] = MAX_VALUE - x1;
+        tempvar x2 = hash256_ptr[2 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 4] = x2;
+        assert [range_check_ptr + 5] = MAX_VALUE - x2;
+        tempvar x3 = hash256_ptr[3 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 6] = x3;
+        assert [range_check_ptr + 7] = MAX_VALUE - x3;
+        tempvar x4 = hash256_ptr[4 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 8] = x4;
+        assert [range_check_ptr + 9] = MAX_VALUE - x4;
+        tempvar x5 = hash256_ptr[5 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 10] = x5;
+        assert [range_check_ptr + 11] = MAX_VALUE - x5;
+        tempvar x6 = hash256_ptr[6 * HASH256_INSTANCE_FELT_SIZE];
+        assert [range_check_ptr + 12] = x6;
+        assert [range_check_ptr + 13] = MAX_VALUE - x6;
+
+        assert [outputs] = x0 + 2 ** (35 * 1) * x1 + 2 ** (35 * 2) * x2 + 2 ** (35 * 3) * x3 +
+                                2 ** (35 * 4) * x4 + 2 ** (35 * 5) * x5 + 2 ** (35 * 6) * x6;
+
+        tempvar outputs = outputs + 1;
+        tempvar hash256_ptr = hash256_ptr + 1;
+        tempvar range_check_ptr = range_check_ptr + 14;
+        tempvar m = m - 1;
+        jmp output_loop if m != 0;
 
     return _finalize_hash256_inner(hash256_start + HASH256_INSTANCE_FELT_SIZE * BLOCK_SIZE, n - 1, initial_state, round_constants);
 }

diff --git a/program/src/utils/chain_state_utils.cairo b/program/src/utils/chain_state_utils.cairo
@@ -87,13 +87,11 @@ func validate_block_headers{
     }
     alloc_locals;
 
-    with hash256_ptr, chain_state {
-        // Get the next block header
-        let block_header = fetch_block_header(chain_state.block_height + 1);
+    // Get the next block header
+    let block_header = fetch_block_header(chain_state.block_height + 1);
 
-        // Validate the block header and get the new state
-        validate_and_apply_block_header(block_header);
-    }
+    // Validate the block header and get the new state
+    validate_and_apply_block_header(block_header);
 
     let block_hash = block_hash_to_felt(chain_state.best_block_hash);
     assert [block_hashes] = block_hash;

diff --git a/program/src/utils/pow2.cairo b/program/src/utils/pow2.cairo
@@ -1,6 +1,4 @@
 from starkware.cairo.common.registers import get_label_location
-from starkware.cairo.common.cairo_builtins import BitwiseBuiltin
-from starkware.cairo.common.bitwise import bitwise_and
 from starkware.cairo.common.alloc import alloc
 
 // Ensures that 0 <= x < 256

diff --git a/program/src/utils/utils.cairo b/program/src/utils/utils.cairo
@@ -7,9 +7,12 @@ const BYTE = 2 ** 8;
 const UINT16 = 2 ** 16;
 const UINT32 = 2 ** 32;
 
-// The byte size Uint32
+// The byte size of Uint32
 const UINT32_SIZE = 4;
 
+// The felt size of a hash
+const HASH_FELT_SIZE = 8;
+
 // Swap the endianness of an uint32
 //
 func byteswap32{bitwise_ptr: BitwiseBuiltin*}(uint32) -> felt {
@@ -25,8 +28,7 @@ func byteswap32{bitwise_ptr: BitwiseBuiltin*}(uint32) -> felt {
 }
 
 
-const HASH_FELT_SIZE = 8;
-const HASH_SIZE = HASH_FELT_SIZE * UINT32_SIZE;
+
 
 // Assert equality of two hashes represented as an array of 8 x Uint32
 //