Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
data_copy.test.cpp
Go to the documentation of this file.
1#include "barretenberg/vm2/simulation/gadgets/data_copy.hpp"
2
3#include <gmock/gmock.h>
4#include <gtest/gtest.h>
5
6#include "barretenberg/vm2/common/aztec_constants.hpp"
7#include "barretenberg/vm2/common/memory_types.hpp"
8#include "barretenberg/vm2/constraining/flavor_settings.hpp"
9#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
10#include "barretenberg/vm2/generated/relations/lookups_data_copy.hpp"
11#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
12#include "barretenberg/vm2/simulation/events/gt_event.hpp"
13#include "barretenberg/vm2/simulation/events/range_check_event.hpp"
14#include "barretenberg/vm2/simulation/gadgets/range_check.hpp"
15#include "barretenberg/vm2/simulation/standalone/pure_gt.hpp"
16#include "barretenberg/vm2/simulation/standalone/pure_memory.hpp"
17#include "barretenberg/vm2/simulation/testing/mock_context.hpp"
18#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp"
19#include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp"
20#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp"
21#include "barretenberg/vm2/testing/fixtures.hpp"
22#include "barretenberg/vm2/testing/macros.hpp"
23#include "barretenberg/vm2/tooling/debugger.hpp"
24#include "barretenberg/vm2/tracegen/calldata_trace.hpp"
25#include "barretenberg/vm2/tracegen/data_copy_trace.hpp"
26#include "barretenberg/vm2/tracegen/execution_trace.hpp"
27#include "barretenberg/vm2/tracegen/gt_trace.hpp"
28#include "barretenberg/vm2/tracegen/range_check_trace.hpp"
29#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
30
31namespace bb::avm2::constraining {
32namespace {
33
34using namespace simulation;
35using ::testing::Return;
36using ::testing::ReturnRef;
37using ::testing::StrictMock;
38using tracegen::DataCopyTraceBuilder;
39using tracegen::ExecutionTraceBuilder;
40using tracegen::TestTraceContainer;
41
42using FF = AvmFlavorSettings::FF;
43using C = Column;
44using data_copy = bb::avm2::data_copy<FF>;
45
46class DataCopyConstrainingBuilderTest : public ::testing::Test {
47 protected:
48 DataCopyConstrainingBuilderTest() { EXPECT_CALL(context, get_memory).WillRepeatedly(ReturnRef(mem)); }
49
50 ExecutionIdManager execution_id_manager = ExecutionIdManager(0);
51 EventEmitter<RangeCheckEvent> range_check_event_emitter;
52 RangeCheck range_check = RangeCheck(range_check_event_emitter);
53 EventEmitter<GreaterThanEvent> gt_event_emitter;
54 StrictMock<MockFieldGreaterThan> mock_field_gt;
55 GreaterThan gt = GreaterThan(mock_field_gt, range_check, gt_event_emitter);
56 EventEmitter<DataCopyEvent> event_emitter;
57 DataCopy copy_data = DataCopy(execution_id_manager, gt, event_emitter);
58 StrictMock<MockContext> context;
59
60 MemoryStore mem;
61
62 TestTraceContainer trace;
63 uint32_t dst_addr = 0; // Destination address in memory for the data.
64 const std::vector<FF> data = { 1, 2, 3, 4, 5, 6, 7, 8 };
65};
66
67class NestedCdConstrainingBuilderTest : public DataCopyConstrainingBuilderTest {
68 protected:
69 NestedCdConstrainingBuilderTest()
70 {
71 // Set up parent context
72 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(true));
73 EXPECT_CALL(context, get_parent_id).WillRepeatedly(Return(1));
74 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(2));
75 EXPECT_CALL(context, get_parent_cd_size).WillRepeatedly(Return(data.size()));
76 EXPECT_CALL(context, get_parent_cd_addr).WillRepeatedly(Return(0));
77 }
78};
79
80TEST_F(NestedCdConstrainingBuilderTest, CdZeroCopy)
81{
82 uint32_t copy_size = 0;
83 uint32_t cd_offset = 0; // Offset into calldata
84
85 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(::testing::Return(std::vector<FF>{}));
86
87 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
88
89 tracegen::DataCopyTraceBuilder builder;
90 builder.process(event_emitter.dump_events(), trace);
91
92 tracegen::GreaterThanTraceBuilder gt_builder;
93 gt_builder.process(gt_event_emitter.dump_events(), trace);
94
95 check_relation<data_copy>(trace);
96 check_interaction<DataCopyTraceBuilder,
97 lookup_data_copy_max_read_index_gt_settings,
98 lookup_data_copy_offset_gt_max_read_index_settings,
99 lookup_data_copy_check_src_addr_in_range_settings,
100 lookup_data_copy_check_dst_addr_in_range_settings>(trace);
101}
102
103TEST_F(NestedCdConstrainingBuilderTest, SimpleNestedCdCopy)
104{
105 uint32_t copy_size = static_cast<uint32_t>(data.size());
106 uint32_t cd_offset = 0; // Offset into calldata
107
108 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(data));
109
110 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
111
112 DataCopyTraceBuilder builder;
113 builder.process(event_emitter.dump_events(), trace);
114
115 tracegen::GreaterThanTraceBuilder gt_builder;
116 gt_builder.process(gt_event_emitter.dump_events(), trace);
117
118 check_relation<data_copy>(trace);
119 check_interaction<DataCopyTraceBuilder,
120 lookup_data_copy_max_read_index_gt_settings,
121 lookup_data_copy_offset_gt_max_read_index_settings,
122 lookup_data_copy_check_src_addr_in_range_settings,
123 lookup_data_copy_check_dst_addr_in_range_settings>(trace);
124}
125
126TEST_F(NestedCdConstrainingBuilderTest, NestedCdCopyPadded)
127{
128 uint32_t cd_offset = 0;
129
130 std::vector<FF> result_cd = data;
131 ASSERT_LT(result_cd.size(), 10); // Ensure we have less than 10 elements so we can pad
132 result_cd.resize(10, 0); // Pad with zeros to 10 elements
133 uint32_t copy_size = static_cast<uint32_t>(result_cd.size()); // Request more than available
134
135 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(result_cd));
136
137 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
138
139 DataCopyTraceBuilder builder;
140 builder.process(event_emitter.dump_events(), trace);
141
142 tracegen::GreaterThanTraceBuilder gt_builder;
143 gt_builder.process(gt_event_emitter.dump_events(), trace);
144
145 check_relation<data_copy>(trace);
146 check_interaction<DataCopyTraceBuilder,
147 lookup_data_copy_max_read_index_gt_settings,
148 lookup_data_copy_offset_gt_max_read_index_settings,
149 lookup_data_copy_check_src_addr_in_range_settings,
150 lookup_data_copy_check_dst_addr_in_range_settings>(trace);
151}
152
153TEST_F(NestedCdConstrainingBuilderTest, NestedCdCopyPartial)
154{
155 uint32_t offset = 3;
156 uint32_t size = 4;
157
158 // Starting at offset = 3
159 std::vector<FF> result_cd = { data.begin() + offset, data.begin() + offset + size };
160
161 EXPECT_CALL(context, get_calldata(offset, size)).WillOnce(Return(result_cd));
162
163 copy_data.cd_copy(context, size, offset, dst_addr);
164
165 DataCopyTraceBuilder builder;
166 builder.process(event_emitter.dump_events(), trace);
167
168 tracegen::GreaterThanTraceBuilder gt_builder;
169 gt_builder.process(gt_event_emitter.dump_events(), trace);
170
171 check_relation<data_copy>(trace);
172 check_interaction<DataCopyTraceBuilder,
173 lookup_data_copy_max_read_index_gt_settings,
174 lookup_data_copy_offset_gt_max_read_index_settings,
175 lookup_data_copy_check_src_addr_in_range_settings,
176 lookup_data_copy_check_dst_addr_in_range_settings>(trace);
177}
178
179TEST_F(NestedCdConstrainingBuilderTest, OutofRangeError)
180{
181 uint32_t offset = 10; // Offset beyond the size of calldata
182 uint32_t size = 4;
183
184 uint32_t big_dst_addr = AVM_HIGHEST_MEM_ADDRESS - 1;
185 EXPECT_THROW_WITH_MESSAGE(copy_data.cd_copy(context, size, offset, big_dst_addr), "Error during CD/RD copy");
186
187 DataCopyTraceBuilder builder;
188 builder.process(event_emitter.dump_events(), trace);
189
190 tracegen::GreaterThanTraceBuilder gt_builder;
191 gt_builder.process(gt_event_emitter.dump_events(), trace);
192
193 check_relation<data_copy>(trace);
194 check_interaction<DataCopyTraceBuilder,
195 lookup_data_copy_max_read_index_gt_settings,
196 lookup_data_copy_offset_gt_max_read_index_settings,
197 lookup_data_copy_check_src_addr_in_range_settings,
198 lookup_data_copy_check_dst_addr_in_range_settings>(trace);
199}
200
201class EnqueuedCdConstrainingBuilderTest : public DataCopyConstrainingBuilderTest {
202 protected:
203 EnqueuedCdConstrainingBuilderTest()
204 {
205 // Set up for enqueued call
206 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(false));
207 EXPECT_CALL(context, get_parent_id).WillRepeatedly(Return(0));
208 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(1));
209 EXPECT_CALL(context, get_parent_cd_size).WillRepeatedly(Return(data.size()));
210 EXPECT_CALL(context, get_parent_cd_addr).WillRepeatedly(Return(0));
211
212 // Build Calldata Column
213 tracegen::CalldataTraceBuilder calldata_builder;
214 CalldataEvent cd_event = {
215 .context_id = 1,
216 .calldata_size = static_cast<uint32_t>(data.size()),
217 .calldata = data,
218 };
219 calldata_builder.process_retrieval({ cd_event }, trace);
220 }
221};
222
223TEST_F(EnqueuedCdConstrainingBuilderTest, CdZeroCopy)
224{
225 uint32_t copy_size = 0;
226 uint32_t cd_offset = 0; // Offset into calldata
227
228 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(::testing::Return(std::vector<FF>{}));
229
230 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
231
232 tracegen::DataCopyTraceBuilder builder;
233 builder.process(event_emitter.dump_events(), trace);
234
235 tracegen::GreaterThanTraceBuilder gt_builder;
236 gt_builder.process(gt_event_emitter.dump_events(), trace);
237
238 check_relation<data_copy>(trace);
239 check_all_interactions<DataCopyTraceBuilder>(trace);
240}
241
242TEST_F(EnqueuedCdConstrainingBuilderTest, SimpleEnqueuedCdCopy)
243{
244 auto copy_size = static_cast<uint32_t>(data.size());
245 uint32_t cd_offset = 0;
246
247 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(data));
248
249 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
250
251 DataCopyTraceBuilder builder;
252 builder.process(event_emitter.dump_events(), trace);
253
254 tracegen::GreaterThanTraceBuilder gt_builder;
255 gt_builder.process(gt_event_emitter.dump_events(), trace);
256
257 check_relation<data_copy>(trace);
258 check_all_interactions<DataCopyTraceBuilder>(trace);
259}
260
261TEST_F(EnqueuedCdConstrainingBuilderTest, EnqueuedCallCdCopyPadding)
262{
263 uint32_t cd_offset = 0;
264 std::vector<FF> result_cd = data;
265 ASSERT_LT(result_cd.size(), 10); // Ensure we have less than 10 elements so we can pad
266 result_cd.resize(10, 0); // Pad with zeros to 10 elements
267 auto copy_size = static_cast<uint32_t>(result_cd.size()); // Request more than available
268
269 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(result_cd));
270
271 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
272
273 DataCopyTraceBuilder builder;
274 builder.process(event_emitter.dump_events(), trace);
275
276 tracegen::GreaterThanTraceBuilder gt_builder;
277 gt_builder.process(gt_event_emitter.dump_events(), trace);
278
279 check_relation<data_copy>(trace);
280 check_all_interactions<DataCopyTraceBuilder>(trace);
281}
282
283TEST_F(EnqueuedCdConstrainingBuilderTest, EnqueuedCallCdCopyPartial)
284{
285 uint32_t offset = 3;
286 uint32_t size = 4;
287
288 // Starting at offset = 3
289 std::vector<FF> result_cd = { data.begin() + offset, data.begin() + offset + size };
290
291 EXPECT_CALL(context, get_calldata(offset, size)).WillOnce(Return(result_cd));
292
293 copy_data.cd_copy(context, size, offset, dst_addr);
294
295 DataCopyTraceBuilder builder;
296 builder.process(event_emitter.dump_events(), trace);
297
298 tracegen::GreaterThanTraceBuilder gt_builder;
299 gt_builder.process(gt_event_emitter.dump_events(), trace);
300
301 check_relation<data_copy>(trace);
302 check_all_interactions<DataCopyTraceBuilder>(trace);
303}
304
305class EnqueuedEmptyCdConstrainingBuilderTest : public DataCopyConstrainingBuilderTest {
306 protected:
307 EnqueuedEmptyCdConstrainingBuilderTest()
308 {
309 // Set up for enqueued call
310 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(false));
311 EXPECT_CALL(context, get_parent_id).WillRepeatedly(Return(0));
312 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(1));
313 EXPECT_CALL(context, get_parent_cd_size).WillRepeatedly(Return(0));
314 EXPECT_CALL(context, get_parent_cd_addr).WillRepeatedly(Return(0));
315
316 // Build Calldata Column
317 tracegen::CalldataTraceBuilder calldata_builder;
318 CalldataEvent cd_event = {
319 .context_id = 1,
320 .calldata_size = 0,
321 .calldata = {},
322 };
323 calldata_builder.process_retrieval({ cd_event }, trace);
324 }
325};
326
327TEST_F(EnqueuedEmptyCdConstrainingBuilderTest, CdZeroCopy)
328{
329 uint32_t copy_size = 0;
330 uint32_t cd_offset = 0; // Offset into calldata
331
332 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(::testing::Return(std::vector<FF>{}));
333
334 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
335
336 tracegen::DataCopyTraceBuilder builder;
337 builder.process(event_emitter.dump_events(), trace);
338
339 tracegen::GreaterThanTraceBuilder gt_builder;
340 gt_builder.process(gt_event_emitter.dump_events(), trace);
341
342 check_relation<data_copy>(trace);
343 check_all_interactions<DataCopyTraceBuilder>(trace);
344}
345
346TEST_F(EnqueuedEmptyCdConstrainingBuilderTest, SimpleEnqueuedCdCopy)
347{
348 uint32_t copy_size = 4;
349 uint32_t cd_offset = 0;
350
351 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(std::vector<FF>{ 0, 0, 0, 0 }));
352
353 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
354
355 DataCopyTraceBuilder builder;
356 builder.process(event_emitter.dump_events(), trace);
357
358 tracegen::GreaterThanTraceBuilder gt_builder;
359 gt_builder.process(gt_event_emitter.dump_events(), trace);
360
361 check_relation<data_copy>(trace);
362 check_all_interactions<DataCopyTraceBuilder>(trace);
363}
364
365TEST_F(EnqueuedEmptyCdConstrainingBuilderTest, EnqueuedCallCdCopyPadding)
366{
367 uint32_t cd_offset = 0;
368 std::vector<FF> result_cd = {};
369 result_cd.resize(10, 0); // Pad with zeros to 10 elements
370 auto copy_size = static_cast<uint32_t>(result_cd.size()); // Request more than available
371
372 EXPECT_CALL(context, get_calldata(cd_offset, copy_size)).WillOnce(Return(result_cd));
373
374 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
375
376 DataCopyTraceBuilder builder;
377 builder.process(event_emitter.dump_events(), trace);
378
379 tracegen::GreaterThanTraceBuilder gt_builder;
380 gt_builder.process(gt_event_emitter.dump_events(), trace);
381
382 check_relation<data_copy>(trace);
383 check_all_interactions<DataCopyTraceBuilder>(trace);
384}
385
387// DataCopy Tests with Execution Permutation
389
390TEST(DataCopyWithExecutionPerm, CdCopy)
391{
392 // Current Context
393 uint32_t context_id = 2;
394 uint32_t cd_offset = 3;
395 uint32_t copy_size = 4;
396 MemoryAddress dst_addr = 0xdeadbeef; // Destination address in memory for the data.
397 // Parent Context
398 uint32_t parent_context_id = 99; // Parent context ID
399 uint32_t parent_cd_addr = 0xc0ffee; // Parent calldata address in memory.
400 const std::vector<FF> data = { 8, 7, 6, 5, 4, 3, 2, 1 };
401
402 // Set up Memory
403 MemoryStore mem(static_cast<uint16_t>(context_id));
404
405 // Execution clk is 0 for this test
406 StrictMock<MockExecutionIdManager> execution_id_manager;
407 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(0));
408
409 // Mock current context
410 StrictMock<MockContext> context;
411 EXPECT_CALL(context, get_memory).WillRepeatedly(ReturnRef(mem));
412 EXPECT_CALL(context, get_parent_cd_size).WillRepeatedly(Return(data.size()));
413 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(true));
414 EXPECT_CALL(context, get_parent_cd_addr).WillRepeatedly(Return(parent_cd_addr));
415 EXPECT_CALL(context, get_calldata(cd_offset, copy_size))
416 .WillRepeatedly(::testing::Invoke([&data, cd_offset, copy_size]() {
417 // Return a slice of data from the calldata
418 return std::vector<FF>(data.begin() + cd_offset, data.begin() + cd_offset + copy_size);
419 }));
420 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(context_id));
421 EXPECT_CALL(context, get_parent_id).WillRepeatedly(Return(parent_context_id));
422
423 PureGreaterThan gt;
424
425 EventEmitter<DataCopyEvent> event_emitter;
426 DataCopy copy_data = DataCopy(execution_id_manager, gt, event_emitter);
427 // Set up execution trace
428 TestTraceContainer trace({
429 {
430 { C::precomputed_first_row, 1 },
431 { C::execution_sel, 1 },
432 { C::execution_context_id, context_id },
433 { C::execution_parent_id, parent_context_id },
434 { C::execution_sel_exec_dispatch_calldata_copy, 1 },
435 { C::execution_register_0_, copy_size },
436 { C::execution_register_1_, cd_offset },
437 { C::execution_rop_2_, dst_addr },
438 { C::execution_sel_opcode_error, 0 },
439 { C::execution_parent_calldata_addr, parent_cd_addr },
440 { C::execution_parent_calldata_size, static_cast<uint32_t>(data.size()) },
441 },
442 });
443
444 copy_data.cd_copy(context, copy_size, cd_offset, dst_addr);
445
446 DataCopyTraceBuilder builder;
447 builder.process(event_emitter.dump_events(), trace);
448
449 check_relation<data_copy>(trace);
450 check_interaction<ExecutionTraceBuilder,
451 perm_execution_dispatch_to_cd_copy_settings,
452 perm_execution_dispatch_to_rd_copy_settings>(trace);
453}
454
455class NestedRdConstrainingBuilderTest : public DataCopyConstrainingBuilderTest {
456 protected:
457 NestedRdConstrainingBuilderTest()
458 {
459 // Set up parent context
460 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(true));
461 EXPECT_CALL(context, get_last_child_id).WillRepeatedly(Return(2));
462 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(2));
463 EXPECT_CALL(context, get_last_rd_size).WillRepeatedly(Return(data.size()));
464 EXPECT_CALL(context, get_last_rd_addr).WillRepeatedly(Return(0));
465 }
466};
467
468TEST_F(NestedRdConstrainingBuilderTest, RdZeroCopy)
469{
470 uint32_t copy_size = 0;
471 uint32_t rd_offset = 0; // Offset into calldata
472
473 EXPECT_CALL(context, get_returndata(rd_offset, copy_size)).WillOnce(::testing::Return(std::vector<FF>{}));
474
475 copy_data.rd_copy(context, copy_size, rd_offset, dst_addr);
476
477 tracegen::DataCopyTraceBuilder builder;
478 builder.process(event_emitter.dump_events(), trace);
479
480 tracegen::GreaterThanTraceBuilder gt_builder;
481 gt_builder.process(gt_event_emitter.dump_events(), trace);
482
483 check_relation<data_copy>(trace);
484 check_all_interactions<DataCopyTraceBuilder>(trace);
485}
486
487TEST(DataCopyWithExecutionPerm, RdCopy)
488{
489 // Current Context
490 uint32_t context_id = 2;
491 uint32_t rd_offset = 3;
492 uint32_t copy_size = 4;
493 MemoryAddress dst_addr = 0xdeadbeef; // Destination address in memory for the data.
494 // Child Context
495 uint32_t child_context_id = 1; // Child context ID
496 MemoryAddress child_rd_addr = 0xc0ffee; // Child returndata address in memory.
497 const std::vector<FF> data = { 1, 2, 3, 4, 5, 6, 7, 8 };
498
499 // Set up Memory
500 MemoryStore mem;
501
502 StrictMock<MockExecutionIdManager> execution_id_manager;
503 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(0));
504 StrictMock<MockContext> context;
505 EXPECT_CALL(context, get_memory).WillRepeatedly(ReturnRef(mem));
506 EXPECT_CALL(context, get_last_rd_size).WillRepeatedly(Return(data.size()));
507 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(true));
508 EXPECT_CALL(context, get_last_rd_addr).WillRepeatedly(Return(child_rd_addr));
509 EXPECT_CALL(context, get_returndata(rd_offset, copy_size))
510 .WillRepeatedly(::testing::Invoke([&data, rd_offset, copy_size]() {
511 // Return a slice of data from the calldata
512 return std::vector<FF>(data.begin() + rd_offset, data.begin() + rd_offset + copy_size);
513 }));
514 EXPECT_CALL(context, get_last_child_id).WillRepeatedly(Return(child_context_id));
515 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(context_id));
516
517 PureGreaterThan gt;
518
519 EventEmitter<DataCopyEvent> event_emitter;
520 DataCopy copy_data = DataCopy(execution_id_manager, gt, event_emitter);
521 // Set up execution trace
522 TestTraceContainer trace({
523 {
524 { C::precomputed_first_row, 1 },
525 { C::execution_sel, 1 },
526 { C::execution_context_id, context_id },
527 { C::execution_last_child_id, child_context_id },
528 { C::execution_sel_exec_dispatch_returndata_copy, 1 },
529 { C::execution_register_0_, copy_size },
530 { C::execution_register_1_, rd_offset },
531 { C::execution_rop_2_, dst_addr },
532 { C::execution_sel_opcode_error, 0 },
533 { C::execution_last_child_returndata_addr, child_rd_addr },
534 { C::execution_last_child_returndata_size, static_cast<uint32_t>(data.size()) },
535 },
536 });
537
538 copy_data.rd_copy(context, copy_size, rd_offset, dst_addr);
539
540 DataCopyTraceBuilder builder;
541 builder.process(event_emitter.dump_events(), trace);
542
543 check_relation<data_copy>(trace);
544 check_interaction<ExecutionTraceBuilder,
545 perm_execution_dispatch_to_cd_copy_settings,
546 perm_execution_dispatch_to_rd_copy_settings>(trace);
547}
548
549TEST(DataCopyWithExecutionPerm, ErrorPropagation)
550{
551 // Current Context
552 uint32_t context_id = 2;
553 uint32_t rd_offset = 10;
554 uint32_t copy_size = 4;
555 MemoryAddress big_dst_addr = AVM_HIGHEST_MEM_ADDRESS - 1;
556
557 // Child context
558 uint32_t child_context_id = 3; // Child context ID
559 uint32_t child_rd_addr = 0xc0ffee; // Last child returndata address in memory.
560 uint32_t child_data_size = 10; // Size of the last child returndata.
561
562 MemoryStore mem;
563 StrictMock<MockContext> context;
564 EXPECT_CALL(context, get_memory).WillRepeatedly(ReturnRef(mem));
565 EXPECT_CALL(context, get_last_rd_size).WillRepeatedly(Return(child_data_size));
566 EXPECT_CALL(context, has_parent).WillRepeatedly(Return(true));
567 EXPECT_CALL(context, get_last_rd_addr).WillRepeatedly(Return(child_rd_addr));
568 EXPECT_CALL(context, get_context_id).WillRepeatedly(Return(context_id));
569 EXPECT_CALL(context, get_last_child_id).WillRepeatedly(Return(child_context_id));
570
571 StrictMock<MockExecutionIdManager> execution_id_manager;
572 EXPECT_CALL(execution_id_manager, get_execution_id()).WillOnce(Return(0));
573
574 PureGreaterThan gt;
575
576 EventEmitter<DataCopyEvent> event_emitter;
577 DataCopy copy_data = DataCopy(execution_id_manager, gt, event_emitter);
578
579 TestTraceContainer trace({
580 {
581 { C::precomputed_first_row, 1 },
582 { C::execution_sel, 1 },
583 { C::execution_context_id, context_id },
584 { C::execution_last_child_id, child_context_id },
585 { C::execution_sel_exec_dispatch_returndata_copy, 1 },
586 { C::execution_register_0_, copy_size },
587 { C::execution_register_1_, rd_offset },
588 { C::execution_rop_2_, big_dst_addr },
589 { C::execution_sel_opcode_error, 1 }, // Error flag is on
590 { C::execution_last_child_returndata_addr, child_rd_addr },
591 { C::execution_last_child_returndata_size, child_data_size },
592 },
593 });
594
595 EXPECT_THROW_WITH_MESSAGE(copy_data.rd_copy(context, copy_size, rd_offset, big_dst_addr),
596 "Error during CD/RD copy");
597
598 DataCopyTraceBuilder builder;
599 builder.process(event_emitter.dump_events(), trace);
600
601 check_relation<data_copy>(trace);
602 check_interaction<ExecutionTraceBuilder,
603 perm_execution_dispatch_to_cd_copy_settings,
604 perm_execution_dispatch_to_rd_copy_settings>(trace);
605}
606
607} // namespace
608} // namespace bb::avm2::constraining
aztec_constants.hpp
AVM_HIGHEST_MEM_ADDRESS
#define AVM_HIGHEST_MEM_ADDRESS
Definition aztec_constants.hpp:44
calldata_trace.hpp
check_relation.hpp
bb::avm2::data_copy
Definition data_copy.hpp:37
bb::avm2::simulation::DataCopy::cd_copy
void cd_copy(ContextInterface &context, const uint32_t cd_copy_size, const uint32_t cd_offset, const MemoryAddress dst_addr) override
Writes calldata into dst_addr. There is slight difference in how enqueued and nested contexts,...
Definition data_copy.cpp:85
bb::avm2::simulation::DataCopy::rd_copy
void rd_copy(ContextInterface &context, const uint32_t rd_copy_size, const uint32_t rd_offset, const MemoryAddress dst_addr) override
Copies returndata from the last executed context to the dst_addr.
Definition data_copy.cpp:143
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Definition alu_trace.cpp:308
bb::avm2::tracegen::GreaterThanTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::GreaterThanEvent >::Container &events, TraceContainer &trace)
Definition gt_trace.cpp:11
bb::crypto::merkle_tree::MemoryStore
Definition memory_store.hpp:15
builder
AluTraceBuilder builder
Definition alu.test.cpp:123
gt_builder
GreaterThanTraceBuilder gt_builder
Definition alu.test.cpp:122
copy_data
DataCopy copy_data
Definition data_copy.test.cpp:57
gt_event_emitter
EventEmitter< GreaterThanEvent > gt_event_emitter
Definition data_copy.test.cpp:53
execution_id_manager
ExecutionIdManager execution_id_manager
Definition data_copy.test.cpp:50
mem
MemoryStore mem
Definition data_copy.test.cpp:60
range_check_event_emitter
EventEmitter< RangeCheckEvent > range_check_event_emitter
Definition data_copy.test.cpp:51
data
const std::vector< FF > data
Definition data_copy.test.cpp:64
mock_field_gt
StrictMock< MockFieldGreaterThan > mock_field_gt
Definition data_copy.test.cpp:54
event_emitter
EventEmitter< DataCopyEvent > event_emitter
Definition data_copy.test.cpp:56
dst_addr
uint32_t dst_addr
Definition data_copy.test.cpp:63
range_check
RangeCheck range_check
Definition data_copy.test.cpp:52
gt
GreaterThan gt
Definition data_copy.test.cpp:55
trace
TestTraceContainer trace
Definition data_copy.test.cpp:62
context
StrictMock< MockContext > context
Definition data_copy.test.cpp:58
data_copy_trace.hpp
offset
ssize_t offset
Definition engine.cpp:36
event_emitter.hpp
execution_trace.hpp
flavor_settings.hpp
gt_event.hpp
gt_trace.hpp
lookups_data_copy.hpp
EXPECT_THROW_WITH_MESSAGE
#define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage)
Definition macros.hpp:7
memory_types.hpp
mock_context.hpp
mock_execution_id_manager.hpp
mock_field_gt.hpp
mock_range_check.hpp
bb::avm2::constraining::TEST_F
TEST_F(AvmRecursiveTests, GoblinRecursion)
A test of the Goblinized AVM recursive verifier.
Definition recursive_verifier.test.cpp:71
bb::avm2::constraining::check_interaction
void check_interaction(tracegen::TestTraceContainer &trace)
Definition check_relation.hpp:76
bb::avm2::constraining::TEST
TEST(TxExecutionConstrainingTest, WriteTreeValue)
Definition tx.test.cpp:402
bb::avm2::lookup_data_copy_check_dst_addr_in_range_settings
lookup_settings< lookup_data_copy_check_dst_addr_in_range_settings_ > lookup_data_copy_check_dst_addr_in_range_settings
Definition lookups_data_copy.hpp:86
bb::avm2::perm_execution_dispatch_to_cd_copy_settings
permutation_settings< perm_execution_dispatch_to_cd_copy_settings_ > perm_execution_dispatch_to_cd_copy_settings
Definition perms_execution.hpp:49
bb::avm2::lookup_data_copy_max_read_index_gt_settings
lookup_settings< lookup_data_copy_max_read_index_gt_settings_ > lookup_data_copy_max_read_index_gt_settings
Definition lookups_data_copy.hpp:34
bb::avm2::lookup_data_copy_check_src_addr_in_range_settings
lookup_settings< lookup_data_copy_check_src_addr_in_range_settings_ > lookup_data_copy_check_src_addr_in_range_settings
Definition lookups_data_copy.hpp:60
bb::avm2::lookup_data_copy_offset_gt_max_read_index_settings
lookup_settings< lookup_data_copy_offset_gt_max_read_index_settings_ > lookup_data_copy_offset_gt_max_read_index_settings
Definition lookups_data_copy.hpp:112
bb::avm2::MemoryAddress
uint32_t MemoryAddress
Definition memory_types.hpp:11
bb::avm2::perm_execution_dispatch_to_rd_copy_settings
permutation_settings< perm_execution_dispatch_to_rd_copy_settings_ > perm_execution_dispatch_to_rd_copy_settings
Definition perms_execution.hpp:89
bb::FF
typename Flavor::FF FF
Definition protogalaxy.bench.cpp:15
pure_gt.hpp
pure_memory.hpp
range_check_event.hpp
range_check_trace.hpp
context_id
uint32_t context_id
Definition calldata_hashing.test.cpp:40
data_copy.hpp
child_rd_addr
uint32_t child_rd_addr
Definition data_copy.test.cpp:173
parent_cd_addr
uint32_t parent_cd_addr
Definition data_copy.test.cpp:62
child_context_id
uint32_t child_context_id
Definition data_copy.test.cpp:174
data_copy
DataCopy data_copy
Definition data_copy.test.cpp:42
cd_offset
uint32_t cd_offset
Definition data_copy.test.cpp:64
range_check.hpp
test_trace_container.hpp