Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
emit_unencrypted_log.test.cpp
Go to the documentation of this file.
1#include "barretenberg/vm2/simulation/gadgets/emit_unencrypted_log.hpp"
2
3#include <gmock/gmock.h>
4#include <gtest/gtest.h>
5
6#include "barretenberg/vm2/common/memory_types.hpp"
7#include "barretenberg/vm2/simulation/testing/mock_context.hpp"
8#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp"
9#include "barretenberg/vm2/simulation/testing/mock_gt.hpp"
10#include "barretenberg/vm2/simulation/testing/mock_memory.hpp"
11
12namespace bb::avm2::simulation {
13
14using ::testing::_;
15using ::testing::ElementsAre;
16using ::testing::Return;
17using ::testing::ReturnRef;
18using ::testing::StrictMock;
19
20TEST(EmitUnencryptedLogTest, Basic)
21{
22 StrictMock<MockMemory> memory;
23 StrictMock<MockContext> context;
24 StrictMock<MockGreaterThan> greater_than;
25 StrictMock<MockExecutionIdManager> execution_id_manager;
26 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
27
28 AztecAddress address = 0xdeadbeef;
29 MemoryAddress log_offset = 27;
30 uint32_t log_size = 2;
31 uint64_t end_log_address = 28;
32 SideEffectStates side_effect_states = { .numUnencryptedLogFields = 0 };
33 uint32_t expected_next_num_unencrypted_log_fields = PUBLIC_LOG_HEADER_LENGTH + log_size;
34 SideEffectStates next_side_effect_states = { .numUnencryptedLogFields = expected_next_num_unencrypted_log_fields };
35
36 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
37
38 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(1));
39 EXPECT_CALL(greater_than, gt(expected_next_num_unencrypted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH))
40 .WillOnce(Return(false));
41 EXPECT_CALL(greater_than, gt(end_log_address, AVM_HIGHEST_MEM_ADDRESS)).WillOnce(Return(false));
42
43 EXPECT_CALL(context, get_side_effect_states()).WillOnce(ReturnRef(side_effect_states));
44 EXPECT_CALL(context, set_side_effect_states(next_side_effect_states));
45
46 EXPECT_CALL(memory, get(_)).WillRepeatedly([](MemoryAddress address) -> const MemoryValue& {
47 static thread_local MemoryValue value;
48 value = MemoryValue::from<FF>(FF(address));
49 return value;
50 });
51
52 EXPECT_CALL(memory, get_space_id()).WillOnce(Return(57));
53 EXPECT_CALL(context, get_is_static()).WillOnce(Return(false));
54
55 emit_unencrypted_log.emit_unencrypted_log(memory, context, address, log_offset, log_size);
56
57 EmitUnencryptedLogWriteEvent expect_event = {
58 .execution_clk = 1,
59 .contract_address = address,
60 .space_id = 57,
61 .log_address = log_offset,
62 .log_size = log_size,
63 .prev_num_unencrypted_log_fields = side_effect_states.numUnencryptedLogFields,
64 .next_num_unencrypted_log_fields = next_side_effect_states.numUnencryptedLogFields,
65 .is_static = false,
66 .values = { MemoryValue::from<FF>(FF(log_offset)), MemoryValue::from<FF>(FF(log_offset + 1)) },
67 .error_memory_out_of_bounds = false,
68 .error_too_many_log_fields = false,
69 .error_tag_mismatch = false,
70 };
71
72 EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event));
73}
74
75TEST(EmitUnencryptedLogTest, NegativeMemoryOutOfBounds)
76{
77 StrictMock<MockMemory> memory;
78 StrictMock<MockContext> context;
79 StrictMock<MockGreaterThan> greater_than;
80 StrictMock<MockExecutionIdManager> execution_id_manager;
81 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
82
83 AztecAddress address = 0xdeadbeef;
84 MemoryAddress log_offset = AVM_HIGHEST_MEM_ADDRESS;
85 uint32_t log_size = 2;
86 uint64_t end_log_address = static_cast<uint64_t>(log_offset) + log_size - 1;
87 SideEffectStates side_effect_states = { .numUnencryptedLogFields = 0 };
88 uint32_t expected_next_num_unencrypted_log_fields = PUBLIC_LOG_HEADER_LENGTH + log_size;
89 SideEffectStates next_side_effect_states = { .numUnencryptedLogFields = 0 };
90
91 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
92
93 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(1));
94 EXPECT_CALL(greater_than, gt(expected_next_num_unencrypted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH))
95 .WillOnce(Return(false));
96 EXPECT_CALL(greater_than, gt(end_log_address, AVM_HIGHEST_MEM_ADDRESS)).WillOnce(Return(true));
97
98 EXPECT_CALL(context, get_side_effect_states()).WillOnce(ReturnRef(side_effect_states));
99 EXPECT_CALL(context, set_side_effect_states(next_side_effect_states));
100
101 EXPECT_CALL(memory, get_space_id()).WillOnce(Return(57));
102 EXPECT_CALL(context, get_is_static()).WillOnce(Return(false));
103
104 EXPECT_THROW(emit_unencrypted_log.emit_unencrypted_log(memory, context, address, log_offset, log_size),
105 EmitUnencryptedLogException);
106
107 EmitUnencryptedLogWriteEvent expect_event = {
108 .execution_clk = 1,
109 .contract_address = address,
110 .space_id = 57,
111 .log_address = log_offset,
112 .log_size = log_size,
113 .prev_num_unencrypted_log_fields = side_effect_states.numUnencryptedLogFields,
114 .next_num_unencrypted_log_fields = next_side_effect_states.numUnencryptedLogFields,
115 .is_static = false,
116 .values = {},
117
118 .error_memory_out_of_bounds = true,
119 .error_too_many_log_fields = false,
120 .error_tag_mismatch = false,
121 };
122
123 EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event));
124}
125
126TEST(EmitUnencryptedLogTest, NegativeTooManyLogs)
127{
128 StrictMock<MockMemory> memory;
129 StrictMock<MockContext> context;
130 StrictMock<MockGreaterThan> greater_than;
131 StrictMock<MockExecutionIdManager> execution_id_manager;
132 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
133
134 AztecAddress address = 0xdeadbeef;
135 MemoryAddress log_offset = 27;
136 uint32_t log_size = 2;
137 uint64_t end_log_address = 28;
138 // Minus three so header = 2 + log_size = 2 doesn't fit
139 SideEffectStates side_effect_states = { .numUnencryptedLogFields = FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - 3 };
140 uint32_t expected_next_num_unencrypted_log_fields = FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH + 1;
141 SideEffectStates next_side_effect_states = { .numUnencryptedLogFields = FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - 3 };
142
143 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
144
145 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(1));
146 EXPECT_CALL(greater_than, gt(expected_next_num_unencrypted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH))
147 .WillOnce(Return(true));
148 EXPECT_CALL(greater_than, gt(end_log_address, AVM_HIGHEST_MEM_ADDRESS)).WillOnce(Return(false));
149
150 EXPECT_CALL(context, get_side_effect_states()).WillOnce(ReturnRef(side_effect_states));
151 EXPECT_CALL(context, set_side_effect_states(next_side_effect_states));
152
153 EXPECT_CALL(memory, get(_)).WillRepeatedly([](MemoryAddress address) -> const MemoryValue& {
154 static thread_local MemoryValue value;
155 value = MemoryValue::from<FF>(FF(address));
156 return value;
157 });
158
159 EXPECT_CALL(memory, get_space_id()).WillOnce(Return(57));
160 EXPECT_CALL(context, get_is_static()).WillOnce(Return(false));
161
162 EXPECT_THROW(emit_unencrypted_log.emit_unencrypted_log(memory, context, address, log_offset, log_size),
163 EmitUnencryptedLogException);
164
165 EmitUnencryptedLogWriteEvent expect_event = {
166 .execution_clk = 1,
167 .contract_address = address,
168 .space_id = 57,
169 .log_address = log_offset,
170 .log_size = log_size,
171 .prev_num_unencrypted_log_fields = side_effect_states.numUnencryptedLogFields,
172 .next_num_unencrypted_log_fields = next_side_effect_states.numUnencryptedLogFields,
173 .is_static = false,
174 .values = { MemoryValue::from<FF>(FF(log_offset)), MemoryValue::from<FF>(FF(log_offset + 1)) },
175 .error_memory_out_of_bounds = false,
176 .error_too_many_log_fields = true,
177 .error_tag_mismatch = false,
178 };
179
180 EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event));
181}
182
183TEST(EmitUnencryptedLogTest, NegativeTagMismatch)
184{
185 StrictMock<MockMemory> memory;
186 StrictMock<MockContext> context;
187 StrictMock<MockGreaterThan> greater_than;
188 StrictMock<MockExecutionIdManager> execution_id_manager;
189 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
190
191 AztecAddress address = 0xdeadbeef;
192 MemoryAddress log_offset = 27;
193 uint32_t log_size = 2;
194 uint64_t end_log_address = 28;
195 SideEffectStates side_effect_states = { .numUnencryptedLogFields = 0 };
196 uint32_t expected_next_num_unencrypted_log_fields = PUBLIC_LOG_HEADER_LENGTH + log_size;
197 SideEffectStates next_side_effect_states = { .numUnencryptedLogFields = 0 };
198
199 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
200
201 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(1));
202 EXPECT_CALL(greater_than, gt(expected_next_num_unencrypted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH))
203 .WillOnce(Return(false));
204 EXPECT_CALL(greater_than, gt(end_log_address, AVM_HIGHEST_MEM_ADDRESS)).WillOnce(Return(false));
205
206 EXPECT_CALL(context, get_side_effect_states()).WillOnce(ReturnRef(side_effect_states));
207 EXPECT_CALL(context, set_side_effect_states(next_side_effect_states));
208
209 EXPECT_CALL(memory, get(_)).WillRepeatedly([](MemoryAddress address) -> const MemoryValue& {
210 static thread_local MemoryValue value;
211 value = MemoryValue::from<uint32_t>(address);
212 return value;
213 });
214
215 EXPECT_CALL(memory, get_space_id()).WillOnce(Return(57));
216 EXPECT_CALL(context, get_is_static()).WillOnce(Return(false));
217
218 EXPECT_THROW(emit_unencrypted_log.emit_unencrypted_log(memory, context, address, log_offset, log_size),
219 EmitUnencryptedLogException);
220
221 EmitUnencryptedLogWriteEvent expect_event = {
222 .execution_clk = 1,
223 .contract_address = address,
224 .space_id = 57,
225 .log_address = log_offset,
226 .log_size = log_size,
227 .prev_num_unencrypted_log_fields = side_effect_states.numUnencryptedLogFields,
228 .next_num_unencrypted_log_fields = next_side_effect_states.numUnencryptedLogFields,
229 .is_static = false,
230 .values = { MemoryValue::from<uint32_t>(log_offset), MemoryValue::from<uint32_t>(log_offset + 1) },
231 .error_memory_out_of_bounds = false,
232 .error_too_many_log_fields = false,
233 .error_tag_mismatch = true,
234 };
235
236 EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event));
237}
238
239TEST(EmitUnencryptedLogTest, NegativeStatic)
240{
241 StrictMock<MockMemory> memory;
242 StrictMock<MockContext> context;
243 StrictMock<MockGreaterThan> greater_than;
244 StrictMock<MockExecutionIdManager> execution_id_manager;
245 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
246
247 AztecAddress address = 0xdeadbeef;
248 MemoryAddress log_offset = 27;
249 uint32_t log_size = 2;
250 uint64_t end_log_address = 28;
251 SideEffectStates side_effect_states = { .numUnencryptedLogFields = 0 };
252 uint32_t expected_next_num_unencrypted_log_fields = PUBLIC_LOG_HEADER_LENGTH + log_size;
253 SideEffectStates next_side_effect_states = { .numUnencryptedLogFields = 0 };
254
255 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
256
257 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(1));
258 EXPECT_CALL(greater_than, gt(expected_next_num_unencrypted_log_fields, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH))
259 .WillOnce(Return(false));
260 EXPECT_CALL(greater_than, gt(end_log_address, AVM_HIGHEST_MEM_ADDRESS)).WillOnce(Return(false));
261
262 EXPECT_CALL(context, get_side_effect_states()).WillOnce(ReturnRef(side_effect_states));
263 EXPECT_CALL(context, set_side_effect_states(next_side_effect_states));
264
265 EXPECT_CALL(memory, get(_)).WillRepeatedly([](MemoryAddress address) -> const MemoryValue& {
266 static thread_local MemoryValue value;
267 value = MemoryValue::from<FF>(FF(address));
268 return value;
269 });
270
271 EXPECT_CALL(memory, get_space_id()).WillOnce(Return(57));
272 EXPECT_CALL(context, get_is_static()).WillOnce(Return(true));
273
274 EXPECT_THROW(emit_unencrypted_log.emit_unencrypted_log(memory, context, address, log_offset, log_size),
275 EmitUnencryptedLogException);
276
277 EmitUnencryptedLogWriteEvent expect_event = {
278 .execution_clk = 1,
279 .contract_address = address,
280 .space_id = 57,
281 .log_address = log_offset,
282 .log_size = log_size,
283 .prev_num_unencrypted_log_fields = side_effect_states.numUnencryptedLogFields,
284 .next_num_unencrypted_log_fields = next_side_effect_states.numUnencryptedLogFields,
285 .is_static = true,
286 .values = { MemoryValue::from<FF>(FF(log_offset)), MemoryValue::from<FF>(FF(log_offset + 1)) },
287
288 .error_memory_out_of_bounds = false,
289 .error_too_many_log_fields = false,
290 .error_tag_mismatch = false,
291 };
292
293 EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event));
294}
295
296TEST(EmitUnencryptedLogTest, CheckpointListener)
297{
298 StrictMock<MockMemory> memory;
299 StrictMock<MockContext> context;
300 StrictMock<MockGreaterThan> greater_than;
301 StrictMock<MockExecutionIdManager> execution_id_manager;
302 EventEmitter<EmitUnencryptedLogEvent> event_emitter;
303 EmitUnencryptedLog emit_unencrypted_log(execution_id_manager, greater_than, event_emitter);
304
305 emit_unencrypted_log.on_checkpoint_created();
306 emit_unencrypted_log.on_checkpoint_committed();
307 emit_unencrypted_log.on_checkpoint_reverted();
308 EXPECT_THAT(event_emitter.get_events().size(), 3);
309 EXPECT_THAT(event_emitter.dump_events(),
310 ElementsAre(CheckPointEventType::CREATE_CHECKPOINT,
311 CheckPointEventType::COMMIT_CHECKPOINT,
312 CheckPointEventType::REVERT_CHECKPOINT));
313}
314
315} // namespace bb::avm2::simulation
FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH
#define FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH
Definition aztec_constants.hpp:30
PUBLIC_LOG_HEADER_LENGTH
#define PUBLIC_LOG_HEADER_LENGTH
Definition aztec_constants.hpp:32
AVM_HIGHEST_MEM_ADDRESS
#define AVM_HIGHEST_MEM_ADDRESS
Definition aztec_constants.hpp:44
bb::avm2::emit_unencrypted_log
Definition emit_unencrypted_log.hpp:36
execution_id_manager
ExecutionIdManager execution_id_manager
Definition data_copy.test.cpp:50
event_emitter
EventEmitter< DataCopyEvent > event_emitter
Definition data_copy.test.cpp:56
greater_than
testing::StrictMock< MockGreaterThan > greater_than
Definition gas_tracker.test.cpp:32
memory_types.hpp
mock_context.hpp
mock_execution_id_manager.hpp
mock_gt.hpp
mock_memory.hpp
bb::avm2::simulation::TEST
TEST(EmitUnencryptedLogTest, Basic)
Definition emit_unencrypted_log.test.cpp:20
bb::avm2::MemoryAddress
uint32_t MemoryAddress
Definition memory_types.hpp:11
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
value
FF value
Definition public_data_tree.test.cpp:97
emit_unencrypted_log.hpp