zkevm-rom 0.0.1-security → 6.0.1

package/counters/tests/SHLarithBit.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    0xffffffff => A
+    254 => D
+             :CALL(SHLarithBit)
+
+    %SHLARITHBIT_STEP - STEP:JMPN(failedCounters)
+    %SHLARITHBIT_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %SHLARITHBIT_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %SHLARITHBIT_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %SHLARITHBIT_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %SHLARITHBIT_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %SHLARITHBIT_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/SHRarith.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    0xffffffff => A
+    2 => D
+             :CALL(SHRarith)
+
+    %SHRARITH_STEP - STEP:JMPN(failedCounters)
+    %SHRARITH_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %SHRARITH_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %SHRARITH_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %SHRARITH_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %SHRARITH_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %SHRARITH_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/SHRarithBit.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    0xffffffff => A
+    2 => D
+             :CALL(SHRarithBit)
+
+    %SHRARITHBIT_STEP - STEP:JMPN(failedCounters)
+    %SHRARITHBIT_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %SHRARITHBIT_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %SHRARITHBIT_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %SHRARITHBIT_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %SHRARITHBIT_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %SHRARITHBIT_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/abs.zkasm

@@ -0,0 +1,29 @@
+INCLUDE "../initIncludes.zkasm"
+start:
+    1000000 => GAS
+
+operation:
+    ; @info Get absolute value and sign
+    ; @in A => number to convert
+    ; @out A => Absolut value of A
+    ; @out B => Sign of A [1 if negative, 0 positive]
+    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn => A
+             :CALL(abs)
+
+    %ABS_STEP - STEP:JMPN(failedCounters)
+    %ABS_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %ABS_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %ABS_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %ABS_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %ABS_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %ABS_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+finalizeExecution:
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/addBatchHashByteByByte.zkasm

@@ -0,0 +1,31 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    ;@info: adds data to batchHashdata byte by byte
+    ;@in: A: bytes to add
+    ;@in D: bytes length
+    12 => A
+    31 => D
+             :CALL(addBatchHashByteByByte)
+
+    %ADDBATCHHASH_STEP*D - STEP:JMPN(failedCounters)
+    %ADDBATCHHASH_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %ADDBATCHHASH_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %ADDBATCHHASH_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %ADDBATCHHASH_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %ADDBATCHHASH_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %ADDBATCHHASH_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/computeGasSendCall.zkasm

@@ -0,0 +1,30 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    ; @info Compute gas to send to call following EIP 150
+    ; @in gasCall: gas sent to call
+    ; @out A => min( requested_gas , all_but_one_64th(63/64) )
+    1000000  :MSTORE(gasCall)
+             :CALL(computeGasSendCall)
+
+    %COMPUTEGASSENDCALL_STEP - STEP:JMPN(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %COMPUTEGASSENDCALL_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/divArith.zkasm

@@ -0,0 +1,27 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    10       :MSTORE(arithA)
+    2        :MSTORE(arithB)
+             :CALL(divARITH)
+
+    %DIVARITH_STEP - STEP:JMPN(failedCounters)
+    %DIVARITH_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %DIVARITH_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %DIVARITH_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %DIVARITH_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %DIVARITH_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %DIVARITH_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+finalizeExecution:
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/expAD.zkasm

@@ -0,0 +1,30 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    2 => A
+    2 => D
+             :CALL(expAD)
+
+    %EXPAD_STEP + 300 - STEP:JMPN(failedCounters)
+    23 - CNT_BINARY :JMPNZ(failedCounters)
+    ;%EXPAD_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    5 - CNT_ARITH :JMPNZ(failedCounters)
+    ;%EXPAD_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %EXPAD_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %EXPAD_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %EXPAD_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %EXPAD_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/getLenBits.zkasm

@@ -0,0 +1,30 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    ; @info bits length of B
+    ; @in B => number
+    ; @out A => bits length
+    1000000 => GAS
+
+operation:
+    0xFFFFFFFFFFFFFFFFFFFFn => B
+    80 => C
+            :CALL(getLenBits)
+%GETLENBITS_STEP + %DIVARITH_STEP*C - STEP:JMPN(failedCounters)
+%GETLENBITS_CNT_BINARY + %DIVARITH_CNT_BINARY*C + C - CNT_BINARY :JMPNZ(failedCounters)
+%GETLENBITS_CNT_ARITH + %DIVARITH_CNT_ARITH*C - 1 - CNT_ARITH :JMPNZ(failedCounters)
+%GETLENBITS_CNT_KECCAK_F + %DIVARITH_CNT_KECCAK_F*C - CNT_KECCAK_F :JMPNZ(failedCounters)
+%GETLENBITS_CNT_MEM_ALIGN + %DIVARITH_CNT_MEM_ALIGN*C - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%GETLENBITS_CNT_PADDING_PG + %DIVARITH_CNT_PADDING_PG*C - CNT_PADDING_PG :JMPNZ(failedCounters)
+%GETLENBITS_CNT_POSEIDON_G + %DIVARITH_CNT_POSEIDON_G*C - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/getLenBytes.zkasm

@@ -0,0 +1,32 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    ; @info byte length of B
+    ; @in B => number
+    ; @out A => bytes length
+    1000000 => GAS
+
+operation:
+    0xFFFFFFFFFFFFFFFFFFFFn => B
+    19 => C
+            :CALL(getLenBytes)
+%GETLENBYTES_STEP + %SHRARITH_STEP*C - STEP:JMPN(failedCounters)
+%GETLENBYTES_CNT_BINARY + 60 - CNT_BINARY :JMPNZ(failedCounters)
+;%GETLENBYTES_CNT_BINARY + %SHRARITH_CNT_BINARY*C + C + 1 - CNT_BINARY :JMPNZ(failedCounters)
+%GETLENBYTES_CNT_ARITH + 19 - CNT_ARITH :JMPNZ(failedCounters)
+;%GETLENBYTES_CNT_ARITH + %SHRARITH_CNT_ARITH*C - CNT_ARITH :JMPNZ(failedCounters)
+%GETLENBYTES_CNT_KECCAK_F + %SHRARITH_CNT_KECCAK_F*C - CNT_KECCAK_F :JMPNZ(failedCounters)
+%GETLENBYTES_CNT_MEM_ALIGN + %SHRARITH_CNT_MEM_ALIGN*C - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%GETLENBYTES_CNT_PADDING_PG + %SHRARITH_CNT_PADDING_PG*C - CNT_PADDING_PG :JMPNZ(failedCounters)
+%GETLENBYTES_CNT_POSEIDON_G + %SHRARITH_CNT_POSEIDON_G*C - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/isEmptyAccount.zkasm

@@ -0,0 +1,30 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    ; @info check account is empty ( balance == nonce == code == 0x )
+    ; @in E => address
+    ; @out E => isEmpty => 1 = true, 0 = false
+    56346543 => E
+             :CALL(isEmptyAccount)
+
+    %ISEMPTYACCOUNT_STEP - STEP:JMPN(failedCounters)
+    %ISEMPTYACCOUNT_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %ISEMPTYACCOUNT_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %ISEMPTYACCOUNT_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %ISEMPTYACCOUNT_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %ISEMPTYACCOUNT_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %ISEMPTYACCOUNT_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/mulARITH.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    115792089237316195423570985008687907853269984665640564039457584007913129639935n       :MSTORE(arithA)
+    2        :MSTORE(arithB)
+             :CALL(mulARITH)
+
+    %MULARITH_STEP - STEP:JMPN(failedCounters)
+    %MULARITH_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %MULARITH_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %MULARITH_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %MULARITH_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %MULARITH_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %MULARITH_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+finalizeExecution:
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/offsetUtil.zkasm

@@ -0,0 +1,29 @@
+INCLUDE "../initIncludes.zkasm"
+start:
+    1000000 => GAS
+
+operation:
+    ;Get offset/32 & offset%32
+    ;@in A offset
+    ;@out E offset/32
+    ;@out C offset%32
+    3 => A
+             :CALL(offsetUtil)
+
+    %OFFSETUTIL_STEP - STEP:JMPN(failedCounters)
+    %OFFSETUTIL_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+    %OFFSETUTIL_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+    %OFFSETUTIL_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+    %OFFSETUTIL_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+    %OFFSETUTIL_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+    %OFFSETUTIL_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+finalizeExecution:
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalWait)
+readCode:
+    :RETURN
+failedCounters:
+2 => A
+1       :ASSERT
+
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opADDMOD.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    10 :MSTORE(SP++)
+    3 :MSTORE(SP++)
+    2 :MSTORE(SP++)
+            :JMP(opADDMOD)
+checkCounters:
+%OPADDMOD_STEP - STEP:JMPN(failedCounters)
+%OPADDMOD_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPADDMOD_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPADDMOD_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPADDMOD_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPADDMOD_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPADDMOD_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+            :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opAdd.zkasm

@@ -0,0 +1,27 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    2       :MSTORE(SP++)
+    2       :MSTORE(SP++)
+            :JMP(opADD)
+checkCounters:
+%OPADD_STEP - STEP:JMPN(failedCounters)
+%OPADD_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPADD_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPADD_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPADD_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPADD_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPADD_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opBLOCKHASH.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    2       :HASHK1(0)
+    10      :MSTORE(blockNum)
+    1       :MSTORE(SP++)
+            :JMP(opBLOCKHASH)
+checkCounters:
+%OPBLOCKHASH_STEP - STEP:JMPN(failedCounters)
+%OPBLOCKHASH_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPBLOCKHASH_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPBLOCKHASH_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPBLOCKHASH_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPBLOCKHASH_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPBLOCKHASH_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opCALL.zkasm

@@ -0,0 +1,41 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    1 => CTX
+    100              :MSTORE(storageAddr)
+    100 => A
+    0 => B, C
+    100000 => D
+    $ => SR             :SSTORE
+    ; stack input: [gas, address, value, argsOffset, argsSize, retOffset, retSize]
+    ; stack output: [success]
+    1000     :MSTORE(SP++)
+    43       :MSTORE(SP++)
+    54       :MSTORE(SP++)
+    8        :MSTORE(SP++)
+    10000    :MSTORE(SP++)
+    100      :MSTORE(SP++)
+    1000     :MSTORE(SP++)
+             :JMP(opCALL)
+checkCounters:
+%OPCALL_STEP - STEP:JMPN(failedCounters)
+%OPCALL_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPCALL_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPCALL_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPCALL_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPCALL_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPCALL_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+txType:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opCALLCODE.zkasm

@@ -0,0 +1,41 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    1 => CTX
+    100              :MSTORE(storageAddr)
+    100 => A
+    0 => B, C
+    100000 => D
+    $ => SR             :SSTORE
+    ; stack input: [gas, address, value, argsOffset, argsSize, retOffset, retSize]
+    ; stack output: [success]
+    1000     :MSTORE(SP++)
+    43       :MSTORE(SP++)
+    54       :MSTORE(SP++)
+    8        :MSTORE(SP++)
+    10000    :MSTORE(SP++)
+    100      :MSTORE(SP++)
+    1000     :MSTORE(SP++)
+             :JMP(opCALLCODE)
+checkCounters:
+%OPCALLCODE_STEP - STEP:JMPN(failedCounters)
+%OPCALLCODE_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPCALLCODE_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPCALLCODE_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPCALLCODE_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPCALLCODE_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPCALLCODE_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+txType:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opCALLDATACOPY.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    43       :MSTORE(SP++)
+    54       :MSTORE(SP++)
+    432543     :MSTORE(SP++)
+            :JMP(opCALLDATACOPY)
+checkCounters:
+%OPCALLDATACOPY_STEP - STEP:JMPN(failedCounters)
+%OPCALLDATACOPY_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPCALLDATACOPY_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPCALLDATACOPY_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPCALLDATACOPY_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPCALLDATACOPY_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPCALLDATACOPY_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opCALLDATALOAD.zkasm

@@ -0,0 +1,27 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    128     :MSTORE(txCalldataLen)
+    1       :MSTORE(SP++)
+            :JMP(opCALLDATALOAD)
+checkCounters:
+%OPCALLDATALOAD_STEP - STEP:JMPN(failedCounters)
+%OPCALLDATALOAD_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPCALLDATALOAD_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPCALLDATALOAD_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPCALLDATALOAD_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPCALLDATALOAD_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPCALLDATALOAD_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"

package/counters/tests/opCODECOPY.zkasm

@@ -0,0 +1,28 @@
+INCLUDE "../initIncludes.zkasm"
+
+start:
+    1000000 => GAS
+
+operation:
+    43       :MSTORE(SP++)
+    54       :MSTORE(SP++)
+    432543     :MSTORE(SP++)
+            :JMP(opCODECOPY)
+checkCounters:
+%OPCODECOPY_STEP - STEP:JMPN(failedCounters)
+%OPCODECOPY_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
+%OPCODECOPY_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
+%OPCODECOPY_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
+%OPCODECOPY_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
+%OPCODECOPY_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
+%OPCODECOPY_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+finalizeExecution:
+                                                                        :JMP(finalWait)
+readCode:
+    :JMP(checkCounters)
+failedCounters:
+2 => A
+1       :ASSERT
+INCLUDE "../endIncludes.zkasm"