@zkasm/zkevm-rom 0.0.1-security → 6.0.1

package/main/opcodes/stack-operations.zkasm

@@ -0,0 +1,658 @@
+/**
+ * @link [https://www.evm.codes/#5f?fork=shanghai]
+ * @zk-counters
+ *  - 100 steps
+ * @process-opcode
+ *  - stack input: none
+ *  - stack output: [0]
+ */
+opPUSH0:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    ; check out-of-gas
+    GAS - %GAS_QUICK_STEP => GAS    :JMPN(outOfGas)
+    ; store stack output
+    0                               :MSTORE(SP++); [0 => SP]
+    ; check stack overflow
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+/**
+ * @link [https://www.evm.codes/#60?fork=berlin]
+ * @zk-counters
+ *  - 100 steps (stack) || 400 steps (calldata)
+ *  - 1 binary (stack) || 0 binary (calldata)
+ * @process-opcode
+ *  - stack input: none
+ *  - stack output: [pushed_value]
+ */
+opPUSH1:
+    ; check is a deploy
+    ; if is a deploy, get bytes from memory else, get bytes from stack
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH2:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH3:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH4:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH5:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH6:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH7:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH8:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH9:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH10:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH11:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH12:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH13:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH14:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH15:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH16:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH17:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH18:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH19:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH20:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH21:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH22:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH23:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH24:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH25:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH26:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH27:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH28:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH29:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH30:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH31:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opPUSH32:
+    $ => B                          :MLOAD(isCreateContract), JMPNZ(opAuxPUSHB, opAuxPUSHA)
+
+opAuxPUSHA:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    $ => B              :MLOAD(bytecodeLength)
+    PC + D - B          :JMPN(opAuxPUSHA2)
+    B - PC => D
+
+opAuxPUSHA2:
+    ; check out-of-gas
+    GAS - %GAS_FASTEST_STEP => GAS      :JMPN(outOfGas)
+    ; read bytes from calldata
+    D => E              :CALL(readPush); in: [D,E: bytes to read] out: [E: value read]
+    ; store stack output
+    E                   :MSTORE(SP++); [pushed_value(E) => SP]
+    ; check stack overflow
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow)
+    ; rectify PC
+    PC + D => PC                    :JMP(readCode)
+
+opAuxPUSHB:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 400 :JMPN(outOfCountersStep)
+    ; check is a create/create2
+    $ => A                          :MLOAD(isCreate), JMPNZ(opAuxPUSHBcreate)
+    $ => B                          :MLOAD(txCalldataLen)
+    PC + D - B                      :JMPN(opAuxPUSHB2)
+    B - PC => D
+
+opAuxPUSHB2:
+    ; set bytes length to read to C
+    0 => A
+    D - 1 => C                      :JMPN(opAuxPUSHBend)
+
+
+opAuxPUSHBloop:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+    ; get position where data starts in the tx
+    $ => HASHPOS                    :MLOAD(dataStarts)
+    ; add PC to data starts to point the bytes to read for the push
+    HASHPOS + PC => HASHPOS
+    PC + 1 => PC
+    ; get memory pointer for hashing
+    $ => E                          :MLOAD(batchHashDataId)
+    $ => B                          :HASHK1(E)
+    ; accumulate hash value
+    A + B => A
+    ; decrease length for loop
+    C - 1 => C                      :JMPN(opAuxPUSHBend)
+    1 => D                          :CALL(SHLarith); in: [A: value, D: #bytes to left shift] out: [A: shifted result]
+                                    :JMP(opAuxPUSHBloop)
+
+opAuxPUSHBend:
+    ; check out-of-gas
+    GAS - %GAS_FASTEST_STEP => GAS                  :JMPN(outOfGas)
+    ; store stack output (value)
+    A                               :MSTORE(SP++); [pushed_value(E) => SP]
+    ; check stack overflow
+    %MAX_STACK_SIZE - SP                       :JMPN(stackOverflow, readCode)
+
+opAuxPUSHBcreate:
+    ; get bytes length
+    $ => B                          :MLOAD(txCalldataLen)
+    ; PUSH in a create, we need to get bytes from memory (not calldata)
+    ; get pushed bytes from previous context memory
+    $ => CTX                        :MLOAD(originCTX)
+    ; get offset call position
+    $ => E                          :MLOAD(argsOffsetCall)
+    ; increase current program counter (PC) to offset for getting pushed bytes to read
+    E + PC => E
+    D => C
+    C - B + PC                      :JMPN(opAuxPUSHBcreate2)
+    0 => A
+    B - PC => C                     :JMPZ(opfinalPUSHBcreate)
+
+opAuxPUSHBcreate2:
+    ; set length to read to C for MLOADX call
+                                    :CALL(MLOADX); in: [E: offset, C: length] out: [A: value, E: new offset]
+    ; increase to PC the length of the read bytes
+    PC + D => PC
+    ; put in the lowest significant bytes, align value to right
+    32 - D => D                     :CALL(SHRarith); in: [A: value, D: #bytes to right shift] out: [A: shifted result]
+
+opfinalPUSHBcreate:
+    ; return to current context
+    $ => CTX                        :MLOAD(currentCTX), JMP(opAuxPUSHBend)
+
+/**
+ * @link [https://www.evm.codes/#80?fork=berlin]
+ * @zk-counters
+ *  - 100 steps
+ * @process-opcode
+ *  - stack input: [value]
+ *  - stack output: [duplicated_value, original_value]
+ */
+opDUP1:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    ; check stack underflow
+    SP - 1                      :JMPN(stackUnderflow)
+
+    ; check out-of-gas
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1); [value => A]
+
+    ; store duplicated value
+    A               :MSTORE(SP++); [duplicated_value(A) => SP]
+
+    ; check stack overflow
+    %MAX_STACK_SIZE - SP       :JMPN(stackOverflow, readCode)
+
+opDUP2:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 2                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-2)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP3:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 3                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-3)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP4:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 4                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-4)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP5:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 5                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-5)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP6:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 6                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-6)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP7:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 7                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-7)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP8:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 8                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-8)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP9:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 9                          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-9)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP10:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 10                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-10)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP11:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 11                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-11)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP12:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 12                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-12)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP13:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 13                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-13)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP14:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 14                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-14)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP15:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 15                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-15)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+opDUP16:
+
+    %MAX_CNT_STEPS - STEP - 100     :JMPN(outOfCountersStep)
+
+    SP - 16                         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A                          :MLOAD(SP-16)
+    A                               :MSTORE(SP++)
+    %MAX_STACK_SIZE - SP           :JMPN(stackOverflow, readCode)
+
+/**
+ * @link [https://www.evm.codes/#90?fork=berlin]
+ * @zk-counters
+ *  - 100 steps
+ * @process-opcode
+ *  - stack input: [value_to_swap_a, value_to_swap_b]
+ *  - stack output: [swapped_value_a, swapped_value_b]
+ */
+opSWAP1:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    ; check stack underflow
+    SP - 2          :JMPN(stackUnderflow)
+
+    ; check out-of-gas
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    ; read values from stack
+    $ => A          :MLOAD(SP-1); [value_to_swap_a => A]
+    $ => B          :MLOAD(SP-2); [value_to_swap_b => B]
+    ; store swapped value a
+    A               :MSTORE(SP-2); [swapped_value_a => SP]
+    ; store swapped value b
+    B               :MSTORE(SP-1), JMP(readCode); [swapped_value_b => SP]
+
+opSWAP2:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 3          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-3)
+    A               :MSTORE(SP-3)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP3:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 4          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-4)
+    A               :MSTORE(SP-4)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP4:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 5          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-5)
+    A               :MSTORE(SP-5)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP5:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 6          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-6)
+    A               :MSTORE(SP-6)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP6:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 7          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-7)
+    A               :MSTORE(SP-7)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP7:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 8          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-8)
+    A               :MSTORE(SP-8)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP8:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 9          :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-9)
+    A               :MSTORE(SP-9)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP9:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 10         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-10)
+    A               :MSTORE(SP-10)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP10:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 11         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-11)
+    A               :MSTORE(SP-11)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP11:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 12         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-12)
+    A               :MSTORE(SP-12)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP12:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 13         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-13)
+    A               :MSTORE(SP-13)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP13:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 14         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-14)
+    A               :MSTORE(SP-14)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP14:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 15         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-15)
+    A               :MSTORE(SP-15)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP15:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 16         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-16)
+    A               :MSTORE(SP-16)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+opSWAP16:
+
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    SP - 17         :JMPN(stackUnderflow)
+
+    GAS - %GAS_FASTEST_STEP => GAS  :JMPN(outOfGas)
+
+    $ => A          :MLOAD(SP-1)
+    $ => B          :MLOAD(SP-17)
+    A               :MSTORE(SP-17)
+    B               :MSTORE(SP-1), JMP(readCode)
+
+/**
+ * @link [https://www.evm.codes/#50?fork=berlin]
+ * @zk-counters
+ *  - 100 steps
+ * @process-opcode
+ *  - stack input: [stack_item]
+ *  - stack output: none
+ */
+opPOP:
+    ; checks zk-counters
+    %MAX_CNT_STEPS - STEP - 100 :JMPN(outOfCountersStep)
+
+    ; check stack underflow
+    SP - 1 => SP    :JMPN(stackUnderflow)
+
+    ; check out-of-gas
+    GAS - %GAS_QUICK_STEP => GAS    :JMPN(outOfGas, readCode)