111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235 | @pytest.mark.repricing(max_code_size_ratio=0)
@pytest.mark.parametrize(
"opcode",
[
Op.CREATE,
Op.CREATE2,
],
)
@pytest.mark.parametrize(
"max_code_size_ratio, non_zero_data, value",
[
# To avoid a blowup of combinations, the value dimension is only
# explored for the non-zero data case, so isn't affected by code size
# influence.
pytest.param(0, False, 0, id="0 bytes without value"),
pytest.param(0, False, 1, id="0 bytes with value"),
pytest.param(
0.25, True, 0, id="0.25x max code size with non-zero data"
),
pytest.param(0.25, False, 0, id="0.25x max code size with zero data"),
pytest.param(
0.50, True, 0, id="0.50x max code size with non-zero data"
),
pytest.param(0.50, False, 0, id="0.50x max code size with zero data"),
pytest.param(
0.75, True, 0, id="0.75x max code size with non-zero data"
),
pytest.param(0.75, False, 0, id="0.75x max code size with zero data"),
pytest.param(1.00, True, 0, id="max code size with non-zero data"),
pytest.param(1.00, False, 0, id="max code size with zero data"),
],
)
def test_create(
benchmark_test: BenchmarkTestFiller,
pre: Alloc,
fork: Fork,
opcode: Op,
max_code_size_ratio: float,
non_zero_data: bool,
value: int,
) -> None:
"""Benchmark CREATE and CREATE2 instructions."""
max_code_size = fork.max_code_size()
code_size = int(max_code_size * max_code_size_ratio)
# Deploy the initcode template which has following design:
# ```
# PUSH3(code_size)
# [CODECOPY(DUP1) -- Conditional that non_zero_data is True]
# RETURN(0, DUP1)
# [<pad to code_size>] -- Conditional that non_zero_data is True]
# ```
code = (
Op.PUSH3(code_size)
+ (Op.CODECOPY(size=Op.DUP1) if non_zero_data else Bytecode())
+ Op.RETURN(0, Op.DUP1)
)
if non_zero_data: # Pad to code_size.
code += bytes([i % 256 for i in range(code_size - len(code))])
initcode_template_contract = pre.deploy_contract(code=code)
# Create the benchmark contract which has the following design:
# ```
# PUSH(value)
# [EXTCODECOPY(full initcode_template_contract)
# -> Conditional that non_zero_data is True]
#
# JUMPDEST (#)
# (CREATE|CREATE2)
# (CREATE|CREATE2)
# ...
# JUMP(#)
# ```
setup = (
Op.PUSH3(code_size)
+ Op.PUSH1(value)
+ Op.EXTCODECOPY(
address=initcode_template_contract,
size=Op.DUP2, # DUP2 refers to the EXTCODESIZE value above.
)
)
if opcode == Op.CREATE2:
# For CREATE2, load salt from storage (persist across outer loop calls)
# If storage is 0 (first call), use initial salt of 42.
# Stack after setup: [..., value, code_size, salt]
setup += (
Op.SLOAD(0) # Load saved salt
+ Op.DUP1 # Duplicate for check
+ Op.ISZERO # Check if zero
+ Op.PUSH1(42) # Default salt
+ Op.MUL # 42 if zero, 0 if not
+ Op.ADD # Add to get final salt (saved or 42)
)
attack_block = (
# For CREATE:
# - DUP2 refers to the EXTOCODESIZE value pushed in code_prefix.
# - DUP3 refers to PUSH1(value) above.
Op.POP(Op.CREATE(value=Op.DUP3, offset=0, size=Op.DUP2))
if opcode == Op.CREATE
# For CREATE2: we manually push the arguments because we leverage the
# return value of previous CREATE2 calls as salt for the next CREATE2
# call. After CREATE2, save result to storage for next outer loop call.
# - DUP4 is targeting the PUSH1(value) from the code_prefix.
# - DUP3 is targeting the EXTCODESIZE value pushed in code_prefix.
else Op.DUP3
+ Op.PUSH0
+ Op.DUP4
+ Op.CREATE2
+ Op.DUP1
+ Op.PUSH0
+ Op.SSTORE
)
benchmark_test(
target_opcode=opcode,
code_generator=JumpLoopGenerator(
setup=setup,
attack_block=attack_block,
contract_balance=1_000_000_000 if value > 0 else 0,
),
)
|