Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
avm_io.test.cpp
Go to the documentation of this file.
1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3
4#include "barretenberg/vm2/common/avm_io.hpp"
5
6#include <cstdint>
7
8#include "barretenberg/api/file_io.hpp"
9#include "barretenberg/aztec/aztec_constants.hpp"
10#include "barretenberg/vm2/common/aztec_types.hpp"
11#include "barretenberg/vm2/testing/fixtures.hpp"
12
13namespace bb::avm2 {
14namespace {
15
16using ::testing::SizeIs;
17
18TEST(AvmInputsTest, Deserialization)
19{
20 // cwd is expected to be barretenberg/cpp/build.
21 auto data = read_file("../src/barretenberg/vm2/testing/avm_inputs.testdata.bin");
22 // We only check that deserialization does not crash.
23 // Correctness of the deserialization itself is assumed via MessagePack.
24 // What we are testing here is that the structure of the inputs in TS matches the C++ structs
25 // that we have here. If someone changes the structure of the inputs in TS, this test would
26 // force them to update the C++ structs as well (and therefore any usage of these structs).
27 AvmProvingInputs::from(data);
28}
29
30TEST(AvmInputsTest, FormatTransformations)
31{
32 using ::testing::AllOf;
33 using ::testing::ElementsAre;
34
35 PublicInputs pi = testing::get_minimal_trace_with_pi().second;
36 auto as_cols = pi.to_columns();
37 auto flattened = PublicInputs::columns_to_flat(as_cols);
38 auto unflattened = PublicInputs::flat_to_columns(flattened);
39
40 EXPECT_THAT(as_cols, SizeIs(AVM_NUM_PUBLIC_INPUT_COLUMNS));
41 for (size_t i = 0; i < AVM_NUM_PUBLIC_INPUT_COLUMNS; ++i) {
42 EXPECT_THAT(as_cols[i], SizeIs(AVM_PUBLIC_INPUTS_COLUMN_LENGTHS[i]));
43 }
44 EXPECT_THAT(flattened, SizeIs(AVM_PUBLIC_INPUTS_COLUMNS_COMBINED_LENGTH));
45
46 EXPECT_EQ(as_cols, unflattened);
47}
48
49TEST(AvmInputsTest, ValuesInColumns)
50{
51 // Create a test PublicInputs with specific values in different parts of the struct
52 PublicInputs pi;
53
54 // Set global variables
55 pi.global_variables.chain_id = 123;
56 pi.global_variables.version = 456;
57 pi.global_variables.block_number = 12345;
58 pi.global_variables.slot_number = 67890;
59 pi.global_variables.timestamp = 789000;
60 pi.global_variables.coinbase = 123123;
61 pi.global_variables.fee_recipient = 9876;
62
63 // Set gas fees
64 pi.global_variables.gas_fees.fee_per_da_gas = 111;
65 pi.global_variables.gas_fees.fee_per_l2_gas = 222;
66
67 // Set start tree snapshots
68 pi.start_tree_snapshots.l1_to_l2_message_tree.root = 1000;
69 pi.start_tree_snapshots.l1_to_l2_message_tree.next_available_leaf_index = 2000;
70 pi.start_tree_snapshots.note_hash_tree.root = 3000;
71 pi.start_tree_snapshots.note_hash_tree.next_available_leaf_index = 4000;
72 pi.start_tree_snapshots.nullifier_tree.root = 5000;
73 pi.start_tree_snapshots.nullifier_tree.next_available_leaf_index = 6000;
74 pi.start_tree_snapshots.public_data_tree.root = 7000;
75 pi.start_tree_snapshots.public_data_tree.next_available_leaf_index = 8000;
76
77 // Set gas used
78 pi.start_gas_used.da_gas = 100;
79 pi.start_gas_used.l2_gas = 200;
80
81 // Set gas settings
82 pi.gas_settings.gas_limits.da_gas = 1234;
83 pi.gas_settings.gas_limits.l2_gas = 5678;
84 pi.gas_settings.teardown_gas_limits.da_gas = 9012;
85 pi.gas_settings.teardown_gas_limits.l2_gas = 3456;
86 pi.gas_settings.max_fees_per_gas.fee_per_da_gas = 7890;
87 pi.gas_settings.max_fees_per_gas.fee_per_l2_gas = 1234;
88 pi.gas_settings.max_priority_fees_per_gas.fee_per_da_gas = 5678;
89 pi.gas_settings.max_priority_fees_per_gas.fee_per_l2_gas = 9012;
90
91 // Set fee payer
92 pi.fee_payer = 12345;
93
94 // Set Public Call Request Array Lengths
95 pi.public_call_request_array_lengths.setup_calls = 2;
96 pi.public_call_request_array_lengths.app_logic_calls = 3;
97 pi.public_call_request_array_lengths.teardown_call = true;
98
99 // Set call requests (using all 4 columns)
100 pi.public_setup_call_requests[0].msg_sender = 1111;
101 pi.public_setup_call_requests[0].contract_address = 2222;
102 pi.public_setup_call_requests[0].is_static_call = true;
103 pi.public_setup_call_requests[0].calldata_hash = 3333;
104
105 pi.public_app_logic_call_requests[1].msg_sender = 4444;
106 pi.public_app_logic_call_requests[1].contract_address = 5555;
107 pi.public_app_logic_call_requests[1].is_static_call = false;
108 pi.public_app_logic_call_requests[1].calldata_hash = 6666;
109
110 pi.public_teardown_call_request.msg_sender = 7777;
111 pi.public_teardown_call_request.contract_address = 8888;
112 pi.public_teardown_call_request.is_static_call = true;
113 pi.public_teardown_call_request.calldata_hash = 9999;
114
115 // Set accumulated data array lengths
116 pi.previous_non_revertible_accumulated_data_array_lengths.note_hashes = 10;
117 pi.previous_non_revertible_accumulated_data_array_lengths.nullifiers = 20;
118 pi.previous_non_revertible_accumulated_data_array_lengths.l2_to_l1_msgs = 30;
119
120 pi.previous_revertible_accumulated_data_array_lengths.note_hashes = 40;
121 pi.previous_revertible_accumulated_data_array_lengths.nullifiers = 50;
122 pi.previous_revertible_accumulated_data_array_lengths.l2_to_l1_msgs = 60;
123
124 // Set l2 to l1 messages (using 3 columns)
125 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].message.recipient = 1234;
126 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].message.content = 1357;
127 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].contract_address = 3579;
128
129 // Set accumulated data elements
130 pi.accumulated_data.note_hashes[2] = 54321;
131 pi.accumulated_data.nullifiers[3] = 98765;
132
133 // Set l2 to l1 messages in accumulated data
134 pi.accumulated_data.l2_to_l1_msgs[1].message.recipient = 3333;
135 pi.accumulated_data.l2_to_l1_msgs[1].message.content = 7531;
136 pi.accumulated_data.l2_to_l1_msgs[1].contract_address = 9753;
137
138 // Set public logs (spans multiple rows per log)
139 std::vector<FF> public_log_fields;
140 public_log_fields.reserve(3);
141 for (size_t j = 0; j < 3; ++j) {
142 public_log_fields.push_back(10000 + j);
143 }
144 pi.accumulated_data.public_logs.add_log({
145 .fields = public_log_fields,
146 .contract_address = 11223,
147 });
148
149 // Set public data writes
150 pi.accumulated_data.public_data_writes[1].leaf_slot = 5555;
151 pi.accumulated_data.public_data_writes[1].value = 6666;
152
153 // Set end gas used
154 pi.end_gas_used.da_gas = 5000;
155 pi.end_gas_used.l2_gas = 7000;
156
157 // Set end tree snapshots
158 pi.end_tree_snapshots.l1_to_l2_message_tree.root = 10000;
159 pi.end_tree_snapshots.l1_to_l2_message_tree.next_available_leaf_index = 20000;
160 pi.end_tree_snapshots.note_hash_tree.root = 30000;
161 pi.end_tree_snapshots.note_hash_tree.next_available_leaf_index = 40000;
162 pi.end_tree_snapshots.nullifier_tree.root = 50000;
163 pi.end_tree_snapshots.nullifier_tree.next_available_leaf_index = 60000;
164 pi.end_tree_snapshots.public_data_tree.root = 70000;
165 pi.end_tree_snapshots.public_data_tree.next_available_leaf_index = 80000;
166
167 // Set transaction fee
168 pi.transaction_fee = 9876;
169
170 // Set accumulated data array lengths
171 pi.accumulated_data_array_lengths.note_hashes = 3;
172 pi.accumulated_data_array_lengths.nullifiers = 4;
173 pi.accumulated_data_array_lengths.l2_to_l1_msgs = 2;
174 pi.accumulated_data_array_lengths.public_data_writes = 5;
175
176 // Set reverted flag
177 pi.reverted = true;
178
179 // Get the columns representation
180 auto columns = pi.to_columns();
181
182 // Convert to flat array for easier testing
183 auto flat = PublicInputs::columns_to_flat(columns);
184 EXPECT_THAT(flat, SizeIs(AVM_PUBLIC_INPUTS_COLUMNS_COMBINED_LENGTH));
185
186 // Define column offsets (cumulative per-column lengths, not a uniform stride)
187 const size_t col0_offset = 0;
188 const size_t col1_offset = col0_offset + AVM_PUBLIC_INPUTS_COLUMN_LENGTHS[0];
189 const size_t col2_offset = col1_offset + AVM_PUBLIC_INPUTS_COLUMN_LENGTHS[1];
190 const size_t col3_offset = col2_offset + AVM_PUBLIC_INPUTS_COLUMN_LENGTHS[2];
191
192 // Verify that some specific values are at the expected positions
193
194 // Global variables
195 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_CHAIN_ID_ROW_IDX], pi.global_variables.chain_id);
196 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_VERSION_ROW_IDX], pi.global_variables.version);
197 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_BLOCK_NUMBER_ROW_IDX],
198 pi.global_variables.block_number);
199 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_SLOT_NUMBER_ROW_IDX],
200 pi.global_variables.slot_number);
201 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX], pi.global_variables.timestamp);
202 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_FEE_RECIPIENT_ROW_IDX],
203 pi.global_variables.fee_recipient);
204 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_GAS_FEES_ROW_IDX],
205 pi.global_variables.gas_fees.fee_per_da_gas);
206 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_GAS_FEES_ROW_IDX],
207 pi.global_variables.gas_fees.fee_per_l2_gas);
208 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_COINBASE_ROW_IDX], pi.global_variables.coinbase);
209
210 // Start tree snapshots
211 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX],
212 pi.start_tree_snapshots.l1_to_l2_message_tree.root);
213 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX],
214 pi.start_tree_snapshots.l1_to_l2_message_tree.next_available_leaf_index);
215 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX],
216 pi.start_tree_snapshots.note_hash_tree.root);
217 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX],
218 pi.start_tree_snapshots.note_hash_tree.next_available_leaf_index);
219 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_NULLIFIER_TREE_ROW_IDX],
220 pi.start_tree_snapshots.nullifier_tree.root);
221 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_NULLIFIER_TREE_ROW_IDX],
222 pi.start_tree_snapshots.nullifier_tree.next_available_leaf_index);
223 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_PUBLIC_DATA_TREE_ROW_IDX],
224 pi.start_tree_snapshots.public_data_tree.root);
225 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_START_TREE_SNAPSHOTS_PUBLIC_DATA_TREE_ROW_IDX],
226 pi.start_tree_snapshots.public_data_tree.next_available_leaf_index);
227
228 // Gas used
229 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_START_GAS_USED_ROW_IDX], pi.start_gas_used.da_gas);
230 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_START_GAS_USED_ROW_IDX], pi.start_gas_used.l2_gas);
231
232 // Gas settings
233 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_GAS_LIMITS_ROW_IDX], pi.gas_settings.gas_limits.da_gas);
234 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_GAS_LIMITS_ROW_IDX], pi.gas_settings.gas_limits.l2_gas);
235 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_TEARDOWN_GAS_LIMITS_ROW_IDX],
236 pi.gas_settings.teardown_gas_limits.da_gas);
237 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_TEARDOWN_GAS_LIMITS_ROW_IDX],
238 pi.gas_settings.teardown_gas_limits.l2_gas);
239 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_MAX_FEES_PER_GAS_ROW_IDX],
240 pi.gas_settings.max_fees_per_gas.fee_per_da_gas);
241 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_MAX_FEES_PER_GAS_ROW_IDX],
242 pi.gas_settings.max_fees_per_gas.fee_per_l2_gas);
243 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_MAX_PRIORITY_FEES_PER_GAS_ROW_IDX],
244 pi.gas_settings.max_priority_fees_per_gas.fee_per_da_gas);
245 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_GAS_SETTINGS_MAX_PRIORITY_FEES_PER_GAS_ROW_IDX],
246 pi.gas_settings.max_priority_fees_per_gas.fee_per_l2_gas);
247
248 // Fee payer
249 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX], pi.fee_payer);
250
251 // Public Call Request Array Lengths
252 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_SETUP_CALLS_ROW_IDX],
253 pi.public_call_request_array_lengths.setup_calls);
254 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_APP_LOGIC_CALLS_ROW_IDX],
255 pi.public_call_request_array_lengths.app_logic_calls);
256 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_TEARDOWN_CALL_ROW_IDX],
257 static_cast<uint8_t>(pi.public_call_request_array_lengths.teardown_call));
258
259 // Public call requests (testing use of all 4 columns)
260 size_t setup_row = AVM_PUBLIC_INPUTS_PUBLIC_SETUP_CALL_REQUESTS_ROW_IDX;
261 EXPECT_EQ(flat[col0_offset + setup_row], pi.public_setup_call_requests[0].msg_sender);
262 EXPECT_EQ(flat[col1_offset + setup_row], pi.public_setup_call_requests[0].contract_address);
263 EXPECT_EQ(flat[col2_offset + setup_row], static_cast<uint8_t>(pi.public_setup_call_requests[0].is_static_call));
264 EXPECT_EQ(flat[col3_offset + setup_row], pi.public_setup_call_requests[0].calldata_hash);
265
266 size_t app_logic_row = AVM_PUBLIC_INPUTS_PUBLIC_APP_LOGIC_CALL_REQUESTS_ROW_IDX + 1; // Using the second one
267 EXPECT_EQ(flat[col0_offset + app_logic_row], pi.public_app_logic_call_requests[1].msg_sender);
268 EXPECT_EQ(flat[col1_offset + app_logic_row], pi.public_app_logic_call_requests[1].contract_address);
269 EXPECT_EQ(flat[col2_offset + app_logic_row],
270 static_cast<uint8_t>(pi.public_app_logic_call_requests[1].is_static_call));
271 EXPECT_EQ(flat[col3_offset + app_logic_row], pi.public_app_logic_call_requests[1].calldata_hash);
272
273 size_t teardown_row = AVM_PUBLIC_INPUTS_PUBLIC_TEARDOWN_CALL_REQUEST_ROW_IDX;
274 EXPECT_EQ(flat[col0_offset + teardown_row], pi.public_teardown_call_request.msg_sender);
275 EXPECT_EQ(flat[col1_offset + teardown_row], pi.public_teardown_call_request.contract_address);
276 EXPECT_EQ(flat[col2_offset + teardown_row], static_cast<uint8_t>(pi.public_teardown_call_request.is_static_call));
277 EXPECT_EQ(flat[col3_offset + teardown_row], pi.public_teardown_call_request.calldata_hash);
278
279 // Test previous accumulated data array lengths
280 EXPECT_EQ(flat[col0_offset +
281 AVM_PUBLIC_INPUTS_PREVIOUS_NON_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_NOTE_HASHES_ROW_IDX],
282 pi.previous_non_revertible_accumulated_data_array_lengths.note_hashes);
283 EXPECT_EQ(
284 flat[col0_offset + AVM_PUBLIC_INPUTS_PREVIOUS_NON_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_NULLIFIERS_ROW_IDX],
285 pi.previous_non_revertible_accumulated_data_array_lengths.nullifiers);
286 EXPECT_EQ(flat[col0_offset +
287 AVM_PUBLIC_INPUTS_PREVIOUS_NON_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_L2_TO_L1_MSGS_ROW_IDX],
288 pi.previous_non_revertible_accumulated_data_array_lengths.l2_to_l1_msgs);
289
290 // Test previous revertible accumulated data array lengths
291 EXPECT_EQ(
292 flat[col0_offset + AVM_PUBLIC_INPUTS_PREVIOUS_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_NOTE_HASHES_ROW_IDX],
293 pi.previous_revertible_accumulated_data_array_lengths.note_hashes);
294 EXPECT_EQ(
295 flat[col0_offset + AVM_PUBLIC_INPUTS_PREVIOUS_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_NULLIFIERS_ROW_IDX],
296 pi.previous_revertible_accumulated_data_array_lengths.nullifiers);
297 EXPECT_EQ(
298 flat[col0_offset + AVM_PUBLIC_INPUTS_PREVIOUS_REVERTIBLE_ACCUMULATED_DATA_ARRAY_LENGTHS_L2_TO_L1_MSGS_ROW_IDX],
299 pi.previous_revertible_accumulated_data_array_lengths.l2_to_l1_msgs);
300
301 // Accumulated Data Array Lengths
302 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_ARRAY_LENGTHS_NOTE_HASHES_ROW_IDX],
303 pi.accumulated_data_array_lengths.note_hashes);
304 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_ARRAY_LENGTHS_NULLIFIERS_ROW_IDX],
305 pi.accumulated_data_array_lengths.nullifiers);
306 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_ARRAY_LENGTHS_L2_TO_L1_MSGS_ROW_IDX],
307 pi.accumulated_data_array_lengths.l2_to_l1_msgs);
308 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_ARRAY_LENGTHS_PUBLIC_DATA_WRITES_ROW_IDX],
309 pi.accumulated_data_array_lengths.public_data_writes);
310
311 // Test l2_to_l1_msgs (which use 3 columns)
312 size_t l2_to_l1_msg_row = AVM_PUBLIC_INPUTS_PREVIOUS_NON_REVERTIBLE_ACCUMULATED_DATA_L2_TO_L1_MSGS_ROW_IDX;
313 EXPECT_EQ(flat[col0_offset + l2_to_l1_msg_row],
314 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].message.recipient);
315 EXPECT_EQ(flat[col1_offset + l2_to_l1_msg_row],
316 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].message.content);
317 EXPECT_EQ(flat[col2_offset + l2_to_l1_msg_row],
318 pi.previous_non_revertible_accumulated_data.l2_to_l1_msgs[0].contract_address);
319
320 // End tree snapshots
321 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX],
322 pi.end_tree_snapshots.l1_to_l2_message_tree.root);
323 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX],
324 pi.end_tree_snapshots.l1_to_l2_message_tree.next_available_leaf_index);
325 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX],
326 pi.end_tree_snapshots.note_hash_tree.root);
327 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX],
328 pi.end_tree_snapshots.note_hash_tree.next_available_leaf_index);
329
330 // End gas used
331 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_END_GAS_USED_ROW_IDX], pi.end_gas_used.da_gas);
332 EXPECT_EQ(flat[col1_offset + AVM_PUBLIC_INPUTS_END_GAS_USED_ROW_IDX], pi.end_gas_used.l2_gas);
333
334 // Test note hashes and nullifiers
335 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NOTE_HASHES_ROW_IDX + 2],
336 pi.accumulated_data.note_hashes[2]);
337 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + 3],
338 pi.accumulated_data.nullifiers[3]);
339
340 // Test accumulated l2_to_l1_msgs
341 size_t acc_l2_to_l1_msg_row = AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_L2_TO_L1_MSGS_ROW_IDX + 1; // Using second one
342 EXPECT_EQ(flat[col0_offset + acc_l2_to_l1_msg_row], pi.accumulated_data.l2_to_l1_msgs[1].message.recipient);
343 EXPECT_EQ(flat[col1_offset + acc_l2_to_l1_msg_row], pi.accumulated_data.l2_to_l1_msgs[1].message.content);
344 EXPECT_EQ(flat[col2_offset + acc_l2_to_l1_msg_row], pi.accumulated_data.l2_to_l1_msgs[1].contract_address);
345
346 // Test public logs
347 size_t public_logs_row = AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_PUBLIC_LOGS_ROW_IDX;
348 // Header
349 EXPECT_EQ(flat[col0_offset + public_logs_row], pi.accumulated_data.public_logs.length);
350 // Payload
351 for (size_t j = 0; j < 3; ++j) {
352 EXPECT_EQ(flat[col0_offset + public_logs_row + FLAT_PUBLIC_LOGS_HEADER_LENGTH + j],
353 pi.accumulated_data.public_logs.payload[j]);
354 }
355
356 // Public data writes (uses 2 columns)
357 size_t public_data_write_row = AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_PUBLIC_DATA_WRITES_ROW_IDX + 1;
358 EXPECT_EQ(flat[col0_offset + public_data_write_row], pi.accumulated_data.public_data_writes[1].leaf_slot);
359 EXPECT_EQ(flat[col1_offset + public_data_write_row], pi.accumulated_data.public_data_writes[1].value);
360
361 // Transaction fee
362 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX], pi.transaction_fee);
363
364 // Reverted status
365 EXPECT_EQ(flat[col0_offset + AVM_PUBLIC_INPUTS_REVERTED_ROW_IDX], static_cast<uint8_t>(pi.reverted));
366}
367
368// Checks each per-column length is tight: every column's final row is populated and asserted non-zero,
369// so an over-long length (zero final cell) or a field written past Lᵢ (out-of-bounds write) is caught.
370TEST(AvmInputsTest, ToColumnsPerColumnLengthsAreTight)
371{
372 PublicInputs pi;
373 pi.reverted = true; // col0 last row: reverted
374 pi.accumulated_data.public_data_writes.back().value = 0xdead; // col1 last row: public_data_writes value
375 pi.accumulated_data.l2_to_l1_msgs.back().contract_address = 0xbeef; // col2 last row: l2_to_l1 contract_address
376 pi.public_teardown_call_request.calldata_hash = 0xcafe; // col3 last row: teardown calldata_hash
377
378 auto cols = pi.to_columns();
379
380 for (size_t i = 0; i < AVM_NUM_PUBLIC_INPUT_COLUMNS; ++i) {
381 EXPECT_THAT(cols[i], SizeIs(AVM_PUBLIC_INPUTS_COLUMN_LENGTHS[i]));
382 // A populated final cell means the length matches the last written row exactly.
383 EXPECT_NE(cols[i].back(), FF(0)) << "column " << i << " last row is unexpectedly zero";
384 }
385}
386
387} // namespace
388} // namespace bb::avm2
avm_io.hpp
aztec_types.hpp
file_io.hpp
bb::avm2::testing::get_minimal_trace_with_pi
std::pair< tracegen::TraceContainer, PublicInputs > get_minimal_trace_with_pi()
Definition fixtures.cpp:230
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::avm2::AVM_PUBLIC_INPUTS_COLUMN_LENGTHS
constexpr std::array< std::size_t, AVM_NUM_PUBLIC_INPUT_COLUMNS > AVM_PUBLIC_INPUTS_COLUMN_LENGTHS
Definition constants.hpp:19
bb::read_file
std::vector< uint8_t > read_file(const std::string &filename, size_t bytes=0)
Definition file_io.hpp:31
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
data
std::byte * data
Definition scalar_multiplication_fast.cpp:212
bb::avm2::AvmProvingInputs::from
static AvmProvingInputs from(const std::vector< uint8_t > &data)
Definition avm_io.cpp:122
bb::avm2::PublicInputs::columns_to_flat
static std::vector< FF > columns_to_flat(std::vector< std::vector< FF > > const &columns)
Definition avm_io.cpp:292
bb::avm2::PublicInputs::flat_to_columns
static std::vector< std::vector< FF_ > > flat_to_columns(const std::vector< FF_ > &input)
Definition avm_io.hpp:66