Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
merkle_check_trace.test.cpp
Go to the documentation of this file.
1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3
4#include <cstdint>
5#include <vector>
6
7#include "barretenberg/aztec/aztec_constants.hpp"
8#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
9#include "barretenberg/vm2/common/field.hpp"
10#include "barretenberg/vm2/constraining/flavor_settings.hpp"
11#include "barretenberg/vm2/constraining/full_row.hpp"
12#include "barretenberg/vm2/testing/macros.hpp"
13#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp"
14#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
15
16namespace bb::avm2::tracegen {
17namespace {
18
19using testing::ElementsAre;
20using testing::Field;
21
22using R = TestTraceContainer::Row;
23using Poseidon2 = crypto::Poseidon2<crypto::Poseidon2Bn254ScalarFieldParams>;
24using simulation::MerkleCheckEvent;
25
26TEST(MerkleCheckTraceGenTest, MerkleRead)
27{
28 TestTraceContainer trace;
29 MerkleCheckTraceBuilder builder;
30
31 FF leaf_value = FF(123);
32 uint64_t leaf_index = 1; // Odd index
33
34 // Level 1 sibling
35 FF sibling_value_1 = FF(456);
36
37 // Compute hash for level 1
38 FF left_node_1 = sibling_value_1; // For odd index, sibling is left
39 FF right_node_1 = leaf_value; // For odd index, leaf is right
40 FF output_hash_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), left_node_1, right_node_1 });
41
42 // Level 2 sibling
43 FF sibling_value_2 = FF(789);
44
45 // Compute hash for level 2
46 FF left_node_2 = output_hash_1; // For odd index 1 in level 1, parent is at index 0 (even) in level 2
47 FF right_node_2 = sibling_value_2;
48 FF output_hash_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), left_node_2, right_node_2 });
49
50 std::vector<FF> sibling_path = { sibling_value_1, sibling_value_2 };
51 FF root = output_hash_2; // Root is the final output hash
52
53 MerkleCheckEvent event = { .merkle_hash_domain_separator = DOM_SEP__MERKLE_HASH,
54 .leaf_value = leaf_value,
55 .leaf_index = leaf_index,
56 .sibling_path = sibling_path,
57 .root = root };
58
59 builder.process({ event }, trace);
60
61 EXPECT_THAT(trace.as_rows(),
62 ElementsAre(
63 // First row is empty
64 AllOf(ROW_FIELD_EQ(merkle_check_sel, 0)),
65 // First real row
66 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
67 ROW_FIELD_EQ(merkle_check_write, 0),
68 ROW_FIELD_EQ(merkle_check_read_node, leaf_value),
69 ROW_FIELD_EQ(merkle_check_index, leaf_index),
70 ROW_FIELD_EQ(merkle_check_path_len, 2), // path length starts at 2
71 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(2 - 1).invert()),
72 ROW_FIELD_EQ(merkle_check_read_root, root),
73 ROW_FIELD_EQ(merkle_check_sibling, sibling_value_1),
74 ROW_FIELD_EQ(merkle_check_start, 1),
75 ROW_FIELD_EQ(merkle_check_end, 0), // Not done yet
76 ROW_FIELD_EQ(merkle_check_index_is_even, 0), // Odd index
77 ROW_FIELD_EQ(merkle_check_read_left_node, left_node_1),
78 ROW_FIELD_EQ(merkle_check_read_right_node, right_node_1),
79 ROW_FIELD_EQ(merkle_check_read_output_hash, output_hash_1)),
80 // Second real row
81 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
82 ROW_FIELD_EQ(merkle_check_write, 0),
83 ROW_FIELD_EQ(merkle_check_read_node, output_hash_1), // Previous output becomes new leaf
84 ROW_FIELD_EQ(merkle_check_index, 0), // Index should be 0 at level 2
85 ROW_FIELD_EQ(merkle_check_path_len, 1), // Remaining path length is 0
86 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, 0),
87 ROW_FIELD_EQ(merkle_check_read_root, root),
88 ROW_FIELD_EQ(merkle_check_sibling, sibling_value_2),
89 ROW_FIELD_EQ(merkle_check_start, 0),
90 ROW_FIELD_EQ(merkle_check_end, 1), // Done after two layers
91 ROW_FIELD_EQ(merkle_check_index_is_even, 1),
92 ROW_FIELD_EQ(merkle_check_read_left_node, left_node_2),
93 ROW_FIELD_EQ(merkle_check_read_right_node, right_node_2),
94 ROW_FIELD_EQ(merkle_check_read_output_hash, output_hash_2))));
95}
96
97TEST(MerkleCheckTraceGenTest, MerkleWrite)
98{
99 TestTraceContainer trace;
100 MerkleCheckTraceBuilder builder;
101
102 FF leaf_value = FF(123);
103 FF new_leaf_value = FF(456);
104 uint64_t leaf_index = 1; // Odd index
105
106 // Level 1 sibling
107 FF sibling_value_1 = FF(456);
108
109 // Compute hash for level 1
110 // For odd index, sibling is left, leaf is right
111 FF read_output_hash_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_value_1, leaf_value });
112 FF write_output_hash_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_value_1, new_leaf_value });
113
114 // Level 2 sibling
115 FF sibling_value_2 = FF(789);
116
117 // Compute hash for level 2
118 // For odd index 1 in level 1, parent is at index 0 (even) in level 2
119 FF read_output_hash_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), read_output_hash_1, sibling_value_2 });
120 FF write_output_hash_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), write_output_hash_1, sibling_value_2 });
121
122 std::vector<FF> sibling_path = { sibling_value_1, sibling_value_2 };
123 FF read_root = read_output_hash_2;
124 FF write_root = write_output_hash_2;
125
126 MerkleCheckEvent event = { .merkle_hash_domain_separator = DOM_SEP__MERKLE_HASH,
127 .leaf_value = leaf_value,
128 .new_leaf_value = new_leaf_value,
129 .leaf_index = leaf_index,
130 .sibling_path = sibling_path,
131 .root = read_root,
132 .new_root = write_root };
133
134 builder.process({ event }, trace);
135
136 EXPECT_THAT(trace.as_rows(),
137 ElementsAre(
138 // First row is empty
139 AllOf(ROW_FIELD_EQ(merkle_check_sel, 0)),
140 // First real row
141 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
142 ROW_FIELD_EQ(merkle_check_write, 1),
143 ROW_FIELD_EQ(merkle_check_read_node, leaf_value),
144 ROW_FIELD_EQ(merkle_check_write_node, new_leaf_value),
145 ROW_FIELD_EQ(merkle_check_index, leaf_index),
146 ROW_FIELD_EQ(merkle_check_path_len, 2), // path length starts at 2
147 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(2 - 1).invert()),
148 ROW_FIELD_EQ(merkle_check_read_root, read_root),
149 ROW_FIELD_EQ(merkle_check_write_root, write_root),
150 ROW_FIELD_EQ(merkle_check_sibling, sibling_value_1),
151 ROW_FIELD_EQ(merkle_check_start, 1),
152 ROW_FIELD_EQ(merkle_check_end, 0), // Not done yet
153 ROW_FIELD_EQ(merkle_check_index_is_even, 0), // Odd index
154 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_value_1),
155 ROW_FIELD_EQ(merkle_check_read_right_node, leaf_value),
156 ROW_FIELD_EQ(merkle_check_write_left_node, sibling_value_1),
157 ROW_FIELD_EQ(merkle_check_write_right_node, new_leaf_value),
158 ROW_FIELD_EQ(merkle_check_read_output_hash, read_output_hash_1),
159 ROW_FIELD_EQ(merkle_check_write_output_hash, write_output_hash_1)),
160 // Second real row
161 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
162 ROW_FIELD_EQ(merkle_check_write, 1),
163 ROW_FIELD_EQ(merkle_check_read_node, read_output_hash_1), // Previous output becomes new leaf
164 ROW_FIELD_EQ(merkle_check_write_node, write_output_hash_1),
165 ROW_FIELD_EQ(merkle_check_index, 0), // Index should be 0 at level 2
166 ROW_FIELD_EQ(merkle_check_path_len, 1), // Remaining path length is 0
167 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, 0),
168 ROW_FIELD_EQ(merkle_check_read_root, read_root),
169 ROW_FIELD_EQ(merkle_check_write_root, write_root),
170 ROW_FIELD_EQ(merkle_check_sibling, sibling_value_2),
171 ROW_FIELD_EQ(merkle_check_start, 0),
172 ROW_FIELD_EQ(merkle_check_end, 1), // Done after two layers
173 ROW_FIELD_EQ(merkle_check_index_is_even, 1),
174 ROW_FIELD_EQ(merkle_check_read_left_node, read_output_hash_1),
175 ROW_FIELD_EQ(merkle_check_read_right_node, sibling_value_2),
176 ROW_FIELD_EQ(merkle_check_write_left_node, write_output_hash_1),
177 ROW_FIELD_EQ(merkle_check_write_right_node, sibling_value_2),
178 ROW_FIELD_EQ(merkle_check_read_output_hash, read_output_hash_2),
179 ROW_FIELD_EQ(merkle_check_write_output_hash, write_output_hash_2))));
180}
181
182TEST(MerkleCheckTraceGenTest, MixedEvents)
183{
184 TestTraceContainer trace;
185 MerkleCheckTraceBuilder builder;
186
187 // First event - leaf_index 6 needs path_len 3 to reach root
188 // Binary 110: 6 -> 3 -> 1 -> 0
189 FF leaf_value_1 = FF(111);
190 uint64_t leaf_index_1 = 6;
191 FF sibling_1_level_0 = FF(222);
192 FF sibling_1_level_1 = FF(333);
193 FF sibling_1_level_2 = FF(444);
194
195 // Level 0: index 6 (even), so leaf is left, sibling is right
196 FF hash_1_level_0 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), leaf_value_1, sibling_1_level_0 });
197 // Level 1: index 3 (odd), so hash is right, sibling is left
198 FF hash_1_level_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_1_level_1, hash_1_level_0 });
199 // Level 2: index 1 (odd), so hash is right, sibling is left
200 FF root_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_1_level_2, hash_1_level_1 });
201
202 MerkleCheckEvent event1 = { .merkle_hash_domain_separator = DOM_SEP__MERKLE_HASH,
203 .leaf_value = leaf_value_1,
204 .leaf_index = leaf_index_1,
205 .sibling_path = { sibling_1_level_0, sibling_1_level_1, sibling_1_level_2 },
206 .root = root_1 };
207
208 // Second event - leaf_index 11 needs path_len 4 to reach root
209 // Binary 1011: 11 -> 5 -> 2 -> 1 -> 0
210 FF leaf_value_2 = FF(555);
211 FF new_leaf_value_2 = FF(666);
212 uint64_t leaf_index_2 = 11;
213 FF sibling_2_level_0 = FF(777);
214 FF sibling_2_level_1 = FF(888);
215 FF sibling_2_level_2 = FF(999);
216 FF sibling_2_level_3 = FF(1010);
217
218 // Read path
219 // Level 0: index 11 (odd), so sibling is left, leaf is right
220 FF read_hash_2_level_0 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_0, leaf_value_2 });
221 // Level 1: index 5 (odd), so sibling is left, hash is right
222 FF read_hash_2_level_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_1, read_hash_2_level_0 });
223 // Level 2: index 2 (even), so hash is left, sibling is right
224 FF read_hash_2_level_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), read_hash_2_level_1, sibling_2_level_2 });
225 // Level 3: index 1 (odd), so sibling is left, hash is right
226 FF read_root_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_3, read_hash_2_level_2 });
227
228 // Write path
229 FF write_hash_2_level_0 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_0, new_leaf_value_2 });
230 FF write_hash_2_level_1 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_1, write_hash_2_level_0 });
231 FF write_hash_2_level_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), write_hash_2_level_1, sibling_2_level_2 });
232 FF write_root_2 = Poseidon2::hash({ FF(DOM_SEP__MERKLE_HASH), sibling_2_level_3, write_hash_2_level_2 });
233
234 MerkleCheckEvent event2 = {
235 .merkle_hash_domain_separator = DOM_SEP__MERKLE_HASH,
236 .leaf_value = leaf_value_2,
237 .new_leaf_value = new_leaf_value_2,
238 .leaf_index = leaf_index_2,
239 .sibling_path = { sibling_2_level_0, sibling_2_level_1, sibling_2_level_2, sibling_2_level_3 },
240 .root = read_root_2,
241 .new_root = write_root_2
242 };
243
244 builder.process({ event1, event2 }, trace);
245
246 EXPECT_THAT(trace.as_rows(),
247 ElementsAre(
248 // First row is empty
249 AllOf(ROW_FIELD_EQ(merkle_check_sel, 0)),
250 // Event 1 - Row 1: Level 0 (leaf_index 6)
251 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
252 ROW_FIELD_EQ(merkle_check_write, 0),
253 ROW_FIELD_EQ(merkle_check_read_node, leaf_value_1),
254 ROW_FIELD_EQ(merkle_check_index, 6),
255 ROW_FIELD_EQ(merkle_check_path_len, 3),
256 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(2).invert()),
257 ROW_FIELD_EQ(merkle_check_read_root, root_1),
258 ROW_FIELD_EQ(merkle_check_sibling, sibling_1_level_0),
259 ROW_FIELD_EQ(merkle_check_start, 1),
260 ROW_FIELD_EQ(merkle_check_end, 0),
261 ROW_FIELD_EQ(merkle_check_index_is_even, 1),
262 ROW_FIELD_EQ(merkle_check_read_left_node, leaf_value_1),
263 ROW_FIELD_EQ(merkle_check_read_right_node, sibling_1_level_0),
264 ROW_FIELD_EQ(merkle_check_read_output_hash, hash_1_level_0)),
265 // Event 1 - Row 2: Level 1 (index 3)
266 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
267 ROW_FIELD_EQ(merkle_check_write, 0),
268 ROW_FIELD_EQ(merkle_check_read_node, hash_1_level_0),
269 ROW_FIELD_EQ(merkle_check_index, 3),
270 ROW_FIELD_EQ(merkle_check_path_len, 2),
271 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(1).invert()),
272 ROW_FIELD_EQ(merkle_check_read_root, root_1),
273 ROW_FIELD_EQ(merkle_check_sibling, sibling_1_level_1),
274 ROW_FIELD_EQ(merkle_check_start, 0),
275 ROW_FIELD_EQ(merkle_check_end, 0),
276 ROW_FIELD_EQ(merkle_check_index_is_even, 0),
277 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_1_level_1),
278 ROW_FIELD_EQ(merkle_check_read_right_node, hash_1_level_0),
279 ROW_FIELD_EQ(merkle_check_read_output_hash, hash_1_level_1)),
280 // Event 1 - Row 3: Level 2 (index 1, final)
281 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
282 ROW_FIELD_EQ(merkle_check_write, 0),
283 ROW_FIELD_EQ(merkle_check_read_node, hash_1_level_1),
284 ROW_FIELD_EQ(merkle_check_index, 1),
285 ROW_FIELD_EQ(merkle_check_path_len, 1),
286 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, 0),
287 ROW_FIELD_EQ(merkle_check_read_root, root_1),
288 ROW_FIELD_EQ(merkle_check_sibling, sibling_1_level_2),
289 ROW_FIELD_EQ(merkle_check_start, 0),
290 ROW_FIELD_EQ(merkle_check_end, 1),
291 ROW_FIELD_EQ(merkle_check_index_is_even, 0),
292 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_1_level_2),
293 ROW_FIELD_EQ(merkle_check_read_right_node, hash_1_level_1),
294 ROW_FIELD_EQ(merkle_check_read_output_hash, root_1)),
295 // Event 2 - Row 1: Level 0 (leaf_index 11)
296 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
297 ROW_FIELD_EQ(merkle_check_write, 1),
298 ROW_FIELD_EQ(merkle_check_read_node, leaf_value_2),
299 ROW_FIELD_EQ(merkle_check_write_node, new_leaf_value_2),
300 ROW_FIELD_EQ(merkle_check_index, 11),
301 ROW_FIELD_EQ(merkle_check_path_len, 4),
302 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(3).invert()),
303 ROW_FIELD_EQ(merkle_check_read_root, read_root_2),
304 ROW_FIELD_EQ(merkle_check_write_root, write_root_2),
305 ROW_FIELD_EQ(merkle_check_sibling, sibling_2_level_0),
306 ROW_FIELD_EQ(merkle_check_start, 1),
307 ROW_FIELD_EQ(merkle_check_end, 0),
308 ROW_FIELD_EQ(merkle_check_index_is_even, 0),
309 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_2_level_0),
310 ROW_FIELD_EQ(merkle_check_read_right_node, leaf_value_2),
311 ROW_FIELD_EQ(merkle_check_write_left_node, sibling_2_level_0),
312 ROW_FIELD_EQ(merkle_check_write_right_node, new_leaf_value_2),
313 ROW_FIELD_EQ(merkle_check_read_output_hash, read_hash_2_level_0),
314 ROW_FIELD_EQ(merkle_check_write_output_hash, write_hash_2_level_0)),
315 // Event 2 - Row 2: Level 1 (index 5)
316 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
317 ROW_FIELD_EQ(merkle_check_write, 1),
318 ROW_FIELD_EQ(merkle_check_read_node, read_hash_2_level_0),
319 ROW_FIELD_EQ(merkle_check_write_node, write_hash_2_level_0),
320 ROW_FIELD_EQ(merkle_check_index, 5),
321 ROW_FIELD_EQ(merkle_check_path_len, 3),
322 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(2).invert()),
323 ROW_FIELD_EQ(merkle_check_read_root, read_root_2),
324 ROW_FIELD_EQ(merkle_check_write_root, write_root_2),
325 ROW_FIELD_EQ(merkle_check_sibling, sibling_2_level_1),
326 ROW_FIELD_EQ(merkle_check_start, 0),
327 ROW_FIELD_EQ(merkle_check_end, 0),
328 ROW_FIELD_EQ(merkle_check_index_is_even, 0),
329 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_2_level_1),
330 ROW_FIELD_EQ(merkle_check_read_right_node, read_hash_2_level_0),
331 ROW_FIELD_EQ(merkle_check_write_left_node, sibling_2_level_1),
332 ROW_FIELD_EQ(merkle_check_write_right_node, write_hash_2_level_0),
333 ROW_FIELD_EQ(merkle_check_read_output_hash, read_hash_2_level_1),
334 ROW_FIELD_EQ(merkle_check_write_output_hash, write_hash_2_level_1)),
335 // Event 2 - Row 3: Level 2 (index 2)
336 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
337 ROW_FIELD_EQ(merkle_check_write, 1),
338 ROW_FIELD_EQ(merkle_check_read_node, read_hash_2_level_1),
339 ROW_FIELD_EQ(merkle_check_write_node, write_hash_2_level_1),
340 ROW_FIELD_EQ(merkle_check_index, 2),
341 ROW_FIELD_EQ(merkle_check_path_len, 2),
342 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, FF(1).invert()),
343 ROW_FIELD_EQ(merkle_check_read_root, read_root_2),
344 ROW_FIELD_EQ(merkle_check_write_root, write_root_2),
345 ROW_FIELD_EQ(merkle_check_sibling, sibling_2_level_2),
346 ROW_FIELD_EQ(merkle_check_start, 0),
347 ROW_FIELD_EQ(merkle_check_end, 0),
348 ROW_FIELD_EQ(merkle_check_index_is_even, 1),
349 ROW_FIELD_EQ(merkle_check_read_left_node, read_hash_2_level_1),
350 ROW_FIELD_EQ(merkle_check_read_right_node, sibling_2_level_2),
351 ROW_FIELD_EQ(merkle_check_write_left_node, write_hash_2_level_1),
352 ROW_FIELD_EQ(merkle_check_write_right_node, sibling_2_level_2),
353 ROW_FIELD_EQ(merkle_check_read_output_hash, read_hash_2_level_2),
354 ROW_FIELD_EQ(merkle_check_write_output_hash, write_hash_2_level_2)),
355 // Event 2 - Row 4: Level 3 (index 1, final)
356 AllOf(ROW_FIELD_EQ(merkle_check_sel, 1),
357 ROW_FIELD_EQ(merkle_check_write, 1),
358 ROW_FIELD_EQ(merkle_check_read_node, read_hash_2_level_2),
359 ROW_FIELD_EQ(merkle_check_write_node, write_hash_2_level_2),
360 ROW_FIELD_EQ(merkle_check_index, 1),
361 ROW_FIELD_EQ(merkle_check_path_len, 1),
362 ROW_FIELD_EQ(merkle_check_path_len_min_one_inv, 0),
363 ROW_FIELD_EQ(merkle_check_read_root, read_root_2),
364 ROW_FIELD_EQ(merkle_check_write_root, write_root_2),
365 ROW_FIELD_EQ(merkle_check_sibling, sibling_2_level_3),
366 ROW_FIELD_EQ(merkle_check_start, 0),
367 ROW_FIELD_EQ(merkle_check_end, 1),
368 ROW_FIELD_EQ(merkle_check_index_is_even, 0),
369 ROW_FIELD_EQ(merkle_check_read_left_node, sibling_2_level_3),
370 ROW_FIELD_EQ(merkle_check_read_right_node, read_hash_2_level_2),
371 ROW_FIELD_EQ(merkle_check_write_left_node, sibling_2_level_3),
372 ROW_FIELD_EQ(merkle_check_write_right_node, write_hash_2_level_2),
373 ROW_FIELD_EQ(merkle_check_read_output_hash, read_root_2),
374 ROW_FIELD_EQ(merkle_check_write_output_hash, write_root_2))));
375}
376
377} // namespace
378} // namespace bb::avm2::tracegen
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Process the ALU events and populate the ALU relevant columns in the trace.
Definition alu_trace.cpp:410
bb::avm2::tracegen::TestTraceContainer::as_rows
std::vector< AvmFullRowConstRef > as_rows() const
Definition test_trace_container.cpp:28
bb::crypto::Poseidon2
Native Poseidon2 hash function implementation.
Definition poseidon2.hpp:22
bb::crypto::Poseidon2::hash
static FF hash(const std::vector< FF > &input)
Hashes a vector of field elements.
builder
AluTraceBuilder builder
Definition alu.test.cpp:124
trace
TestTraceContainer trace
Definition data_copy.test.cpp:63
flavor_settings.hpp
full_row.hpp
ROW_FIELD_EQ
#define ROW_FIELD_EQ(field_name, expression)
Definition macros.hpp:7
merkle_check_trace.hpp
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
test_trace_container.hpp