@zkasm/zkevm-rom 0.0.1-security → 6.0.1

package/test/mstorex.zkasm

@@ -0,0 +1,191 @@
+VAR GLOBAL testEoffset
+
+start:
+
+        STEP => A
+        0 :ASSERT
+
+        ; TEST-1 (simple test)
+
+        0 => E      :CALL(fillMemPattern)
+
+        3*32+5 => E
+        0xFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000n :MSTORE(bytesToStore)
+        6 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFn :MLOAD(MEM:E+2)
+        0xC0C1C2C3C4FFFFFFFFFFFFCBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-2 (between memory words)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32+29 => E
+        0xABCDEFFEDCBA0000000000000000000000000000000000000000000000000000n :MSTORE(bytesToStore)
+        6 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCABCDEFn :MLOAD(MEM:E+2)
+        0xFEDCBAC3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-3 (relative offset 0)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32 => E
+        0xABCDEFFEDCBA0000000000000000000000000000000000000000000000000000n :MSTORE(bytesToStore)
+        6 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xABCDEFFEDCBAA6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFn :MLOAD(MEM:E+2)
+        0xC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-4 (32 bytes, offset > 0)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32 + 18 => E
+        0x102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MSTORE(bytesToStore)
+        32 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1102030405060708090A0B0C0D0E0n :MLOAD(MEM:E+2)
+        0xF101112131415161718191A1B1C1D1E20210D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-5 (0 bytes)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32 + 18 => E
+        0x102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MSTORE(bytesToStore)
+        0 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFn :MLOAD(MEM:E+2)
+        0xC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-6 (32 bytes, offset 0)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32 => E
+        0x102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MSTORE(bytesToStore)
+        32 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0x102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MLOAD(MEM:E+2)
+        0xC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-7 (high address)
+
+        2**17-6 => E    :CALL(fillMemPattern)
+
+        2**22-6*32+2*32+29 => E
+        0xABCDEFFEDCBA0000000000000000000000000000000000000000000000000000n :MSTORE(bytesToStore)
+        6 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        2**17-6 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCABCDEFn :MLOAD(MEM:E+2)
+        0xFEDCBAC3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-8 (1 byte, offset = 31)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32+31 => E
+        0x882030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MSTORE(bytesToStore)
+        1 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE88n :MLOAD(MEM:E+2)
+        0xC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        ; TEST-9 (31 bytes, offset = 31)
+
+        0 => E      :CALL(fillMemPattern)
+
+        2*32+31 => E
+        0x882030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E20210n :MSTORE(bytesToStore)
+        31 => C
+        E + C           :MSTORE(testEoffset)
+        :CALL(MSTOREX)
+        E               :MLOAD(testEoffset)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MLOAD(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MLOAD(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBE88n :MLOAD(MEM:E+2)
+        0x2030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E202DEDFn :MLOAD(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MLOAD(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MLOAD(MEM:E+5)
+
+        0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalizeExecution)
+
+fillMemPattern:
+
+        0x0000000000000000000000000000000000000000000000000000000000000000n :MSTORE(MEM:E)
+        0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E2021n :MSTORE(MEM:E+1)
+        0xA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFn :MSTORE(MEM:E+2)
+        0xC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFn :MSTORE(MEM:E+3)
+        0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEn :MSTORE(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn :MSTORE(MEM:E+5), RETURN
+
+INCLUDE "../main/main.zkasm"

package/test/opcalldatacopy.ignore.zkasm

@@ -0,0 +1,331 @@
+; CALLDATACOPY: memory[destOffset:destOffset+length] = msg.data[offset:offset+length]
+;       | destOffset | offset | length | ....
+; SP          0          1         2     .....
+
+start:
+
+        STEP => A
+        0 :ASSERT
+
+        ; TEST 1: size = 20, offset = 0, destOffset = 0, no MEM (simple test)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)    ;destOffset
+        100000000 => GAS
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234512345000000000000000000000000n     :MLOAD(MEM:E+1)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+2)
+
+        ; TEST 2: size = 20, offset = 4, destOffset = 0, no MEM (offset > 0, size + offset < 32)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        4               :MSTORE(SP++)   ;offset
+        32               :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x4512345123451234512345123451234512345123000000000000000000000000n     :MLOAD(MEM:E+1)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+2)
+
+        ; TEST 3: size = 20, offset = 0, destOffset = 7, no MEM (destOffset > 0, size + destOffset < 32)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32+7            :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x0000000000000012345123451234512345123451234512345123450000000000n     :MLOAD(MEM:E+1)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+2)
+
+        ; TEST 4: size = 40, offset = 0, destOffset = 0, no MEM (size > 32)
+
+        0 => SP
+        40              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MLOAD(MEM:E+1)
+        0x6789678967896789000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+2)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+3)
+
+        ; TEST 5: size = 66, offset = 31, destOffset = 0, no MEM (size + offset > 32)
+
+        0 => SP
+        66              :MSTORE(SP++)   ;size
+        15              :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234678967896789678967896789678967n     :MLOAD(MEM:E+1)
+        0x8967896789678967896789678967896789123456789123456789123456789123n     :MLOAD(MEM:E+2)
+        0x4567000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+3)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+4)
+
+        ; TEST 6: size = 65, offset = 3, destOffset = 30, no MEM (size + offset > 32, size + destOffset > 32)
+
+        0 => SP
+        65              :MSTORE(SP++)   ;size
+        3               :MSTORE(SP++)   ;offset
+        32+30           :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern0)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x0000000000000000000000000000000000000000000000000000000000002345n     :MLOAD(MEM:E+1)
+        0x1234512345123451234512345123451234512345123451234512346789678967n     :MLOAD(MEM:E+2)
+        0x8967896789678967896789678967896789678967896789678967891234567800n     :MLOAD(MEM:E+3)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E+4)
+
+        ; TEST 7: size = 20, offset = 0, destOffset = 0, set MEM (simple test)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234512345222222222222222222222222n     :MLOAD(MEM:E+1)
+        0x3333333333333333333333333333333333333333333333333333333333333333n     :MLOAD(MEM:E+2)
+
+        ; TEST 8: size = 20, offset = 4, destOffset = 0, set MEM (offset > 0, size + offset < 32)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        4               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x4512345123451234512345123451234512345123222222222222222222222222n     :MLOAD(MEM:E+1)
+        0x3333333333333333333333333333333333333333333333333333333333333333n     :MLOAD(MEM:E+2)
+
+        ; TEST 9: size = 20, offset = 0, destOffset = 7, set MEM (destOffset > 0, size + destOffset < 32)
+
+        0 => SP
+        20              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32+7            :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x2222222222222212345123451234512345123451234512345123452222222222n     :MLOAD(MEM:E+1)
+        0x3333333333333333333333333333333333333333333333333333333333333333n     :MLOAD(MEM:E+2)
+
+        ; TEST 10: size = 40, offset = 0, destOffset = 0, set MEM (size > 32)
+
+        0 => SP
+        40              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MLOAD(MEM:E+1)
+        0x6789678967896789333333333333333333333333333333333333333333333333n     :MLOAD(MEM:E+2)
+        0x4444444444444444444444444444444444444444444444444444444444444444n     :MLOAD(MEM:E+3)
+
+        ; TEST 11: size = 66, offset = 31, destOffset = 0, set MEM (size + offset > 32)
+
+        0 => SP
+        66              :MSTORE(SP++)   ;size
+        15              :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234678967896789678967896789678967n     :MLOAD(MEM:E+1)
+        0x8967896789678967896789678967896789123456789123456789123456789123n     :MLOAD(MEM:E+2)
+        0x4567444444444444444444444444444444444444444444444444444444444444n     :MLOAD(MEM:E+3)
+        0x5555555555555555555555555555555555555555555555555555555555555555n     :MLOAD(MEM:E+4)
+        ; TEST 12: size = 65, offset = 3, destOffset = 30, set MEM (size + offset > 32, size + destOffset > 32)
+
+        0 => SP
+        65              :MSTORE(SP++)   ;size
+        3               :MSTORE(SP++)   ;offset
+        32+30           :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x2222222222222222222222222222222222222222222222222222222222222345n     :MLOAD(MEM:E+1)
+        0x1234512345123451234512345123451234512345123451234512346789678967n     :MLOAD(MEM:E+2)
+        0x8967896789678967896789678967896789678967896789678967891234567844n     :MLOAD(MEM:E+3)
+        0x5555555555555555555555555555555555555555555555555555555555555555n     :MLOAD(MEM:E+4)
+
+        ; TEST 13: size = 60, offset = 0, destOffset = 0, set MEM (txCalldataLen < size)
+
+        0 => SP
+        60              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        32              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern2)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MLOAD(MEM:E+1)
+        0x6789678967896789678967896789678967890000000000000000000033333333n     :MLOAD(MEM:E+2)
+        0x4444444444444444444444444444444444444444444444444444444444444444n     :MLOAD(MEM:E+3)
+
+        ; TEST 14: size = 90, offset = 0, destOffset = 0, set MEM (txCalldataLen < size)
+        0 => SP
+        90              :MSTORE(SP++)   ;size
+        0               :MSTORE(SP++)   ;offset
+        0               :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern2)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MLOAD(MEM:E)
+        0x6789678967896789678967896789678967890000000000000000000000000000n     :MLOAD(MEM:E+1)
+        0x0000000000000000000000000000000000000000000000000000333333333333n     :MLOAD(MEM:E+2)
+
+        ; TEST 15: size = 40, offset = 20, destOffset = 10, set MEM (txCalldataLen < size)
+
+        0 => SP
+        40             :MSTORE(SP++)   ;size
+        49             :MSTORE(SP++)   ;offset
+        1              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern2)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1189000000000000000000000000000000000000000000000000000000000000n     :MLOAD(MEM:E)
+        0x0000000000000000002222222222222222222222222222222222222222222222n     :MLOAD(MEM:E+1)
+
+        ; TEST 16: size = 20, offset = 52, destOffset = 1, set MEM (offset > txCalldataLen)
+
+        0 => SP
+        20             :MSTORE(SP++)   ;size
+        52             :MSTORE(SP++)   ;offset
+        32+1              :MSTORE(SP)     ;destOffset
+
+        :CALL(fillCalldataPattern2)
+        :CALL(fillMemPattern)
+        :CALL(opCALLDATACOPY2)
+
+        0 => E
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MLOAD(MEM:E)
+        0x2200000000000000000000000000000000000000002222222222222222222222n     :MLOAD(MEM:E+1)
+        0x3333333333333333333333333333333333333333333333333333333333333333n     :MLOAD(MEM:E+2)
+
+0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalizeExecution)
+
+fillCalldataPattern:
+        1024 => SP
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MSTORE(SP++)
+        0x6789678967896789678967896789678967896789678967896789678967896789n     :MSTORE(SP++)
+        0x1234567891234567891234567891234567891234567891234567891234567891n     :MSTORE(SP)
+        3 => SP
+        96                                                                      :MSTORE(txCalldataLen), RETURN
+
+fillCalldataPattern2:
+        1024 => SP
+        0x1234512345123451234512345123451234512345123451234512345123451234n     :MSTORE(SP++)
+        0x6789678967896789678967896789678967890000000000000000000000000000n     :MSTORE(SP++)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(SP)
+        3 => SP
+        50                                                                      :MSTORE(txCalldataLen), RETURN
+
+fillMemPattern0:
+
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E+1)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E+2)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E+3)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E+4)
+        0x0000000000000000000000000000000000000000000000000000000000000000n     :MSTORE(MEM:E+5), RETURN
+
+fillMemPattern:
+
+        0x1111111111111111111111111111111111111111111111111111111111111111n     :MSTORE(MEM:E)
+        0x2222222222222222222222222222222222222222222222222222222222222222n     :MSTORE(MEM:E+1)
+        0x3333333333333333333333333333333333333333333333333333333333333333n     :MSTORE(MEM:E+2)
+        0x4444444444444444444444444444444444444444444444444444444444444444n     :MSTORE(MEM:E+3)
+        0x5555555555555555555555555555555555555555555555555555555555555555n     :MSTORE(MEM:E+4)
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFn     :MSTORE(MEM:E+5), RETURN
+
+INCLUDE "../main/main.zkasm"
+
+VAR GLOBAL tmpSHXZkPCtest
+/**
+ * @link [https://www.evm.codes/#37?fork=berlin]
+ * @zk-counters
+ *  - 100 steps
+ *  - 2 binary
+ * @process-opcode
+ *  - stack input: [destOffset, offset, size]
+ *  - stack output: []
+ */
+opCALLDATACOPY2:
+    RR              :MSTORE(tmpSHXZkPCtest)
+                    :CALL(opCALLDATACOPY)
+
+opCALLDATACOPYend:
+
+    $ => RR         :MLOAD(tmpSHXZkPCtest)
+                    :RETURN

package/test/performance/read-push.zkasm

@@ -0,0 +1,71 @@
+VAR GLOBAL test
+
+;; Comments 'readPush' function
+; @info Read bytes opcode PUSHX
+; @internalParam {numBlocks} 4 bytes blocks to read
+; @internalParam {leftBytes} remaining bytes
+; @in D => bytes to read
+; @out E => value read
+
+start:
+    ; init vars
+    0 => HASHPOS
+    1 => D
+    $${var rounds}
+
+    ; add bytes one by one
+    0x0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20n => A    :CALL(initLoop)
+    0x2122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F40n => A    :CALL(initLoop)
+    0x4142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F60n => A    :CALL(initLoop)
+
+    ; close hash
+    HASHPOS         :HASHPLEN(0)
+    $               :HASHPDIGEST(0)
+    0               :MSTORE(contractHashId)
+
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;;;;;     INIT TESTS     ;;;;;
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ; log init counters
+    CNT_BINARY => A
+    ; ${log(A, binaryCouners)} ; result: 1
+    STEP => A
+    ; ${log(A, stepCounter)} ; result: 202
+
+    ; Start test PUSH1
+
+    ; PUSH1 reading 1 byte at position 0 in the bytecode
+    0 => PC
+    1 => D                 :CALL(readPush)
+    0x01 => A
+    E                       :ASSERT
+
+    ; PUSH1 reading 1 byte at position 1 in the bytecode
+    20 => PC
+    1 => D                 :CALL(readPush)
+    0x02 => A
+    E                       :ASSERT
+
+    ; PUSH1 reading 1 byte at position 2 in the bytecode
+    2 => PC
+    1 => D                 :CALL(readPush)
+    0x03 => A
+    E                       :ASSERT
+
+
+    0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
+                                                                        :JMP(finalizeExecution)
+
+initLoop:
+    $${rounds = 31}
+    0 => B ; to allow $$
+
+loopAdd32Byte:
+    ${(A >> (rounds * 8)) & 0xFF}   :HASHP1(0)
+    $${rounds = rounds - 1}
+    ${rounds}                  :JMPZ(endLoop, loopAdd32Byte)
+
+endLoop:
+                                :RETURN
+
+INCLUDE "../../main/main.zkasm"