zkevm-rom 0.0.1-security → 6.0.1

package/test/testArrayUtils.zkasm

@@ -0,0 +1,335 @@
+; constants needed by executor C++
+INCLUDE "../main/constants.zkasm"
+
+VAR GLOBAL lastHashKId
+VAR GLOBAL lastHashPId
+
+VAR GLOBAL initial_A
+VAR GLOBAL initial_B
+VAR GLOBAL initial_C
+VAR GLOBAL initial_D
+VAR GLOBAL initial_E
+VAR GLOBAL initial_CTX
+VAR GLOBAL initial_SP
+VAR GLOBAL initial_PC
+VAR GLOBAL initial_GAS
+VAR GLOBAL initial_SR
+VAR GLOBAL initial_RR
+VAR GLOBAL initial_HASHPOS
+VAR GLOBAL initial_RCX
+
+; Fix better notation for the above
+
+start:
+
+        STEP => A
+        0 :ASSERT
+
+        A           :MSTORE(initial_A)
+        B           :MSTORE(initial_B)
+        C           :MSTORE(initial_C)
+        D           :MSTORE(initial_D)
+        E           :MSTORE(initial_E)
+        CTX         :MSTORE(initial_CTX)
+        SP          :MSTORE(initial_SP)
+        PC          :MSTORE(initial_PC)
+        GAS         :MSTORE(initial_GAS)
+        SR          :MSTORE(initial_SR)
+        RR          :MSTORE(initial_RR)
+        HASHPOS     :MSTORE(initial_HASHPOS)
+        RCX         :MSTORE(initial_RCX)
+        0 => A,B,C,D,E,CTX, SP, PC, GAS, SR, RR, HASHPOS, RCX
+
+        -1          :MSTORE(lastHashKId)
+        -1          :MSTORE(lastHashPId)
+
+; array_compare
+; ---------------------------------------------------------------
+; 1] inA = [5,6,7], inB = [2,3]. len(inA) > len(inB) should return 2
+array_compare_test_1:
+        3 => C
+        2 => D
+        5n              :MSTORE(array_compare_inA)
+        1 => E
+        6n              :MSTORE(array_compare_inA + E)
+        2 => E
+        7n              :MSTORE(array_compare_inA + E)
+        2n              :MSTORE(array_compare_inB)
+        1 => E
+        3n              :MSTORE(array_compare_inB + E)
+                        :CALL(array_compare)
+        2               :MLOAD(array_compare_result)
+
+; 2] inA = [5,6], inB = [2,3,4]. len(inA) < len(inB) should return 0
+array_compare_test_2:
+        2 => C
+        3 => D
+        5n              :MSTORE(array_compare_inA)
+        1 => E
+        6n              :MSTORE(array_compare_inA + E)
+        2n              :MSTORE(array_compare_inB)
+        1 => E
+        3n              :MSTORE(array_compare_inB + E)
+        2 => E
+        4n              :MSTORE(array_compare_inB + E)
+                        :CALL(array_compare)
+        0               :MLOAD(array_compare_result)
+
+
+
+; 3] inA = [5,6,7], inB = [5,6,6]. len(inA) = len(inB) but inA > inB should return 2
+array_compare_test_3:
+        3 => C
+        3 => D
+        5n              :MSTORE(array_compare_inA)
+        1 => E
+        6n              :MSTORE(array_compare_inA + E)
+        2 => E
+        7n              :MSTORE(array_compare_inA + E)
+        5n              :MSTORE(array_compare_inB)
+        1 => E
+        6n              :MSTORE(array_compare_inB + E)
+        2 => E
+        6n              :MSTORE(array_compare_inB + E)
+                        :CALL(array_compare)
+        2               :MLOAD(array_compare_result)
+
+; 4] inA = [5,6,6], inB = [5,6,7]. len(inA) = len(inB) but inA < inB should return 0
+array_compare_test_4:
+        3 => C
+        3 => D
+        5n              :MSTORE(array_compare_inA)
+        1 => E
+        6n              :MSTORE(array_compare_inA + E)
+        2 => E
+        6n              :MSTORE(array_compare_inA + E)
+
+        5n              :MSTORE(array_compare_inB)
+        1 => E
+        6n              :MSTORE(array_compare_inB + E)
+        2 => E
+        7n              :MSTORE(array_compare_inB + E)
+                        :CALL(array_compare)
+        0               :MLOAD(array_compare_result)
+
+; 5] inA = [5,6,6], inB = [5,6,6]. inA = inB should return 1
+array_compare_test_5:
+        3 => C
+        3 => D
+        5n              :MSTORE(array_compare_inA)
+        1 => E
+        6n              :MSTORE(array_compare_inA + E)
+        2 => E
+        6n              :MSTORE(array_compare_inA + E)
+        5n              :MSTORE(array_compare_inB)
+        1 => E
+        6n              :MSTORE(array_compare_inB + E)
+        2 => E
+        6n              :MSTORE(array_compare_inB + E)
+                        :CALL(array_compare)
+        1               :MLOAD(array_compare_result)
+; ---------------------------------------------------------------
+
+; array unshift
+; ---------------------------------------------------------------
+; 1] in = [3] and D = 5 => in = [5,3]
+array_unshift_test_1:
+        1 => C
+        3n              :MSTORE(array_unshift_in)
+        5 => D
+                        :CALL(array_unshift)
+        5n              :MLOAD(array_unshift_in)
+        1 => E
+        3n              :MLOAD(array_unshift_in + E)
+        2               :MLOAD(array_unshift_len)
+
+; 2] in = [2,1,1] and D = 5 => in = [5,2,1,1]
+array_unshift_test_2:
+        3 => C
+        5 => D
+        2n              :MSTORE(array_unshift_in)
+        1 => E
+        1n              :MSTORE(array_unshift_in + E)
+        2 => E
+        1n              :MSTORE(array_unshift_in + E)
+                        :CALL(array_unshift)
+        5n              :MLOAD(array_unshift_in)
+        1 => E
+        2n              :MLOAD(array_unshift_in + E)
+        2 => E
+        1n              :MLOAD(array_unshift_in + E)
+        3 => E
+        1n              :MLOAD(array_unshift_in + E)
+        4               :MLOAD(array_unshift_len)
+; ---------------------------------------------------------------
+
+; array trim
+; ---------------------------------------------------------------
+; 1] [2,1,0] should return 2
+array_trim_test_1:
+        3 => C
+        2n              :MSTORE(array_trim_in)
+        1 => E
+        1n              :MSTORE(array_trim_in + E)
+        2 => E
+        0n              :MSTORE(array_trim_in + E)
+                        :CALL(array_trim)
+        2 => A
+        C               :ASSERT
+
+; 2] [2,1,0,2] should return 4
+array_trim_test_2:
+        4 => C
+        2n              :MSTORE(array_trim_in)
+        1 => E
+        1n              :MSTORE(array_trim_in + E)
+        2 => E
+        0n              :MSTORE(array_trim_in + E)
+        3 => E
+        2n              :MSTORE(array_trim_in + E)
+                        :CALL(array_trim)
+        4 => A
+        C               :ASSERT
+
+; 3] [0,0,0,0,0,0] should return 1
+array_trim_test_3:
+        6 => C
+        0n              :MSTORE(array_trim_in)
+        1 => E
+        0n              :MSTORE(array_trim_in + E)
+        2 => E
+        0n              :MSTORE(array_trim_in + E)
+        3 => E
+        0n              :MSTORE(array_trim_in + E)
+        4 => E
+        0n              :MSTORE(array_trim_in + E)
+        5 => E
+        0n              :MSTORE(array_trim_in + E)
+                        :CALL(array_trim)
+        1 => A
+        C               :ASSERT
+
+; 4] [0] should return 1
+array_trim_test_4:
+        1 => C
+        0n              :MSTORE(array_trim_in)
+                        :CALL(array_trim)
+        1 => A
+        C               :ASSERT
+; ---------------------------------------------------------------
+
+; array is zero
+; ---------------------------------------------------------------
+; 1] [2,1] should return 0
+array_is_zero_test_1:
+        2 => C
+        2n              :MSTORE(array_is_zero_in)
+        1 => E
+        1n              :MSTORE(array_is_zero_in + E)
+                        :CALL(array_is_zero)
+        0               :MLOAD(array_is_zero_result)
+
+; 2] [0] should return 1
+array_is_zero_test_2:
+        1 => C
+        0n              :MSTORE(array_is_zero_in)
+                        :CALL(array_is_zero)
+        1               :MLOAD(array_is_zero_result)
+
+; 3] [5] should return 0
+array_is_zero_test_3:
+        1 => C
+        5n              :MSTORE(array_is_zero_in)
+                        :CALL(array_is_zero)
+        0               :MLOAD(array_is_zero_result)
+; ---------------------------------------------------------------
+
+; array is one
+; ---------------------------------------------------------------
+; 1] [2,1] should return 0
+array_is_one_test_1:
+        2 => C
+        2n              :MSTORE(array_is_one_in)
+        1 => E
+        1n              :MSTORE(array_is_one_in + E)
+                        :CALL(array_is_one)
+        0               :MLOAD(array_is_one_result)
+
+; 2] [1] should return 1
+array_is_one_test_2:
+        1 => C
+        1n              :MSTORE(array_is_one_in)
+                        :CALL(array_is_one)
+        1               :MLOAD(array_is_one_result)
+
+; 3] [5] should return 0
+array_is_one_test_3:
+        1 => C
+        5n              :MSTORE(array_is_one_in)
+                        :CALL(array_is_one)
+        0               :MLOAD(array_is_one_result)
+; ---------------------------------------------------------------
+
+; array is odd
+; ---------------------------------------------------------------
+; 1] [2,1] should return 0
+array_is_odd_test_1:
+        2n              :MSTORE(array_is_odd_in)
+        1 => E
+        1n              :MSTORE(array_is_odd_in + E)
+                        :CALL(array_is_odd)
+        0               :MLOAD(array_is_odd_result)
+
+; 2] [5] should return 1
+array_is_odd_test_2:
+        5n              :MSTORE(array_is_odd_in)
+                        :CALL(array_is_odd)
+        1               :MLOAD(array_is_odd_result)
+
+; 2] [3, 2] should return 1
+array_is_odd_test_3:
+        3n              :MSTORE(array_is_odd_in)
+        1 => E
+        2n              :MSTORE(array_is_odd_in + E)
+                        :CALL(array_is_odd)
+        1               :MLOAD(array_is_odd_result)
+; ---------------------------------------------------------------
+
+outOfCountersBinary:
+outOfCountersStep:
+
+end:
+
+        $ => A          :MLOAD(initial_A)
+        $ => B          :MLOAD(initial_B)
+        $ => C          :MLOAD(initial_C)
+        $ => D          :MLOAD(initial_D)
+        $ => E          :MLOAD(initial_E)
+        $ => CTX        :MLOAD(initial_CTX)
+        $ => SP         :MLOAD(initial_SP)
+        $ => PC         :MLOAD(initial_PC)
+        $ => GAS        :MLOAD(initial_GAS)
+        $ => SR         :MLOAD(initial_SR)
+        $ => RR         :MLOAD(initial_RR)
+        $ => HASHPOS    :MLOAD(initial_HASHPOS)
+        $ => RCX        :MLOAD(initial_RCX)
+
+; label finalizeExecution needed by executor C++
+finalizeExecution:
+        ${beforeLast()} :JMPN(finalizeExecution)
+
+                        :JMP(start)
+opINVALID:
+; label checkAndSaveFrom needed by executor C++
+checkAndSaveFrom:
+                         :JMP(opINVALID)
+
+INCLUDE "../main/modexp/constants.zkasm"
+
+INCLUDE "../main/modexp/array_lib/utils/array_compare.zkasm"
+INCLUDE "../main/modexp/array_lib/utils/array_trim.zkasm"
+
+INCLUDE "../main/modexp/array_lib/unused/array_is_zero.zkasm"
+INCLUDE "../main/modexp/array_lib/unused/array_is_one.zkasm"
+INCLUDE "../main/modexp/array_lib/unused/array_is_odd.zkasm"
+INCLUDE "../main/modexp/array_lib/unused/array_unshift.zkasm"