ethereum.forks.cancun.vm.instructions.stackethereum.forks.prague.vm.instructions.stack

Ethereum Virtual Machine (EVM) Stack Instructions.

.. contents:: Table of Contents :backlinks: none :local:

Introduction

Implementations of the EVM stack related instructions.

pop

Removes an item from the stack.

Parameters

evm : The current EVM frame.

def pop(​evm: Evm​) -> None:
29
    <snip>
38
    # STACK
39
    stack.pop(evm.stack)
40
41
    # GAS
42
    charge_gas(evm, GasCosts.OPCODE_POP)
43
44
    # OPERATION
45
    pass
46
47
    # PROGRAM COUNTER
48
    evm.pc += Uint(1)

push_n

Pushes an N-byte immediate onto the stack. Push zero if num_bytes is zero.

Parameters

evm : The current EVM frame.

num_bytes : The number of immediate bytes to be read from the code and pushed to the stack. Push zero if num_bytes is zero.

def push_n(​evm: Evm, ​​num_bytes: int​) -> None:
52
    <snip>
65
    # STACK
66
    pass
67
68
    # GAS
69
    if num_bytes == 0:
70
        charge_gas(evm, GasCosts.OPCODE_PUSH0)
71
    else:
72
        charge_gas(evm, GasCosts.OPCODE_PUSH)
73
74
    # OPERATION
75
    data_to_push = U256.from_be_bytes(
76
        buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(num_bytes))
77
    )
78
    stack.push(evm.stack, data_to_push)
79
80
    # PROGRAM COUNTER
81
    evm.pc += Uint(1) + Uint(num_bytes)

dup_n

Duplicates the Nth stack item (from top of the stack) to the top of stack.

Parameters

evm : The current EVM frame.

item_number : The stack item number (0-indexed from top of stack) to be duplicated to the top of stack.

def dup_n(​evm: Evm, ​​item_number: int​) -> None:
85
    <snip>
98
    # STACK
99
    pass
100
101
    # GAS
102
    charge_gas(evm, GasCosts.OPCODE_DUP)
103
    if item_number >= len(evm.stack):
104
        raise StackUnderflowError
105
    data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number]
106
    stack.push(evm.stack, data_to_duplicate)
107
108
    # PROGRAM COUNTER
109
    evm.pc += Uint(1)

swap_n

Swaps the top and the item_number element of the stack, where the top of the stack is position zero.

If item_number is zero, this function does nothing (which should not be possible, since there is no SWAP0 instruction).

Parameters

evm : The current EVM frame.

item_number : The stack item number (0-indexed from top of stack) to be swapped with the top of stack element.

def swap_n(​evm: Evm, ​​item_number: int​) -> None:
113
    <snip>
130
    # STACK
131
    pass
132
133
    # GAS
134
    charge_gas(evm, GasCosts.OPCODE_SWAP)
135
    if item_number >= len(evm.stack):
136
        raise StackUnderflowError
137
    evm.stack[-1], evm.stack[-1 - item_number] = (
138
        evm.stack[-1 - item_number],
139
        evm.stack[-1],
140
    )
141
142
    # PROGRAM COUNTER
143
    evm.pc += Uint(1)

push0

146
push0: Callable[[Evm], None] = partial(push_n, num_bytes=0)

push1

147
push1: Callable[[Evm], None] = partial(push_n, num_bytes=1)

push2

148
push2: Callable[[Evm], None] = partial(push_n, num_bytes=2)

push3

149
push3: Callable[[Evm], None] = partial(push_n, num_bytes=3)

push4

150
push4: Callable[[Evm], None] = partial(push_n, num_bytes=4)

push5

151
push5: Callable[[Evm], None] = partial(push_n, num_bytes=5)

push6

152
push6: Callable[[Evm], None] = partial(push_n, num_bytes=6)

push7

153
push7: Callable[[Evm], None] = partial(push_n, num_bytes=7)

push8

154
push8: Callable[[Evm], None] = partial(push_n, num_bytes=8)

push9

155
push9: Callable[[Evm], None] = partial(push_n, num_bytes=9)

push10

156
push10: Callable[[Evm], None] = partial(push_n, num_bytes=10)

push11

157
push11: Callable[[Evm], None] = partial(push_n, num_bytes=11)

push12

158
push12: Callable[[Evm], None] = partial(push_n, num_bytes=12)

push13

159
push13: Callable[[Evm], None] = partial(push_n, num_bytes=13)

push14

160
push14: Callable[[Evm], None] = partial(push_n, num_bytes=14)

push15

161
push15: Callable[[Evm], None] = partial(push_n, num_bytes=15)

push16

162
push16: Callable[[Evm], None] = partial(push_n, num_bytes=16)

push17

163
push17: Callable[[Evm], None] = partial(push_n, num_bytes=17)

push18

164
push18: Callable[[Evm], None] = partial(push_n, num_bytes=18)

push19

165
push19: Callable[[Evm], None] = partial(push_n, num_bytes=19)

push20

166
push20: Callable[[Evm], None] = partial(push_n, num_bytes=20)

push21

167
push21: Callable[[Evm], None] = partial(push_n, num_bytes=21)

push22

168
push22: Callable[[Evm], None] = partial(push_n, num_bytes=22)

push23

169
push23: Callable[[Evm], None] = partial(push_n, num_bytes=23)

push24

170
push24: Callable[[Evm], None] = partial(push_n, num_bytes=24)

push25

171
push25: Callable[[Evm], None] = partial(push_n, num_bytes=25)

push26

172
push26: Callable[[Evm], None] = partial(push_n, num_bytes=26)

push27

173
push27: Callable[[Evm], None] = partial(push_n, num_bytes=27)

push28

174
push28: Callable[[Evm], None] = partial(push_n, num_bytes=28)

push29

175
push29: Callable[[Evm], None] = partial(push_n, num_bytes=29)

push30

176
push30: Callable[[Evm], None] = partial(push_n, num_bytes=30)

push31

177
push31: Callable[[Evm], None] = partial(push_n, num_bytes=31)

push32

178
push32: Callable[[Evm], None] = partial(push_n, num_bytes=32)

dup1

180
dup1: Callable[[Evm], None] = partial(dup_n, item_number=0)

dup2

181
dup2: Callable[[Evm], None] = partial(dup_n, item_number=1)

dup3

182
dup3: Callable[[Evm], None] = partial(dup_n, item_number=2)

dup4

183
dup4: Callable[[Evm], None] = partial(dup_n, item_number=3)

dup5

184
dup5: Callable[[Evm], None] = partial(dup_n, item_number=4)

dup6

185
dup6: Callable[[Evm], None] = partial(dup_n, item_number=5)

dup7

186
dup7: Callable[[Evm], None] = partial(dup_n, item_number=6)

dup8

187
dup8: Callable[[Evm], None] = partial(dup_n, item_number=7)

dup9

188
dup9: Callable[[Evm], None] = partial(dup_n, item_number=8)

dup10

189
dup10: Callable[[Evm], None] = partial(dup_n, item_number=9)

dup11

190
dup11: Callable[[Evm], None] = partial(dup_n, item_number=10)

dup12

191
dup12: Callable[[Evm], None] = partial(dup_n, item_number=11)

dup13

192
dup13: Callable[[Evm], None] = partial(dup_n, item_number=12)

dup14

193
dup14: Callable[[Evm], None] = partial(dup_n, item_number=13)

dup15

194
dup15: Callable[[Evm], None] = partial(dup_n, item_number=14)

dup16

195
dup16: Callable[[Evm], None] = partial(dup_n, item_number=15)

swap1

197
swap1: Callable[[Evm], None] = partial(swap_n, item_number=1)

swap2

198
swap2: Callable[[Evm], None] = partial(swap_n, item_number=2)

swap3

199
swap3: Callable[[Evm], None] = partial(swap_n, item_number=3)

swap4

200
swap4: Callable[[Evm], None] = partial(swap_n, item_number=4)

swap5

201
swap5: Callable[[Evm], None] = partial(swap_n, item_number=5)

swap6

202
swap6: Callable[[Evm], None] = partial(swap_n, item_number=6)

swap7

203
swap7: Callable[[Evm], None] = partial(swap_n, item_number=7)

swap8

204
swap8: Callable[[Evm], None] = partial(swap_n, item_number=8)

swap9

205
swap9: Callable[[Evm], None] = partial(swap_n, item_number=9)

swap10

206
swap10: Callable[[Evm], None] = partial(swap_n, item_number=10)

swap11

207
swap11: Callable[[Evm], None] = partial(swap_n, item_number=11)

swap12

208
swap12: Callable[[Evm], None] = partial(swap_n, item_number=12)

swap13

209
swap13: Callable[[Evm], None] = partial(swap_n, item_number=13)

swap14

210
swap14: Callable[[Evm], None] = partial(swap_n, item_number=14)

swap15

211
swap15: Callable[[Evm], None] = partial(swap_n, item_number=15)

swap16

212
swap16: Callable[[Evm], None] = partial(swap_n, item_number=16)