Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
contract_instance_retrieval.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 <memory>
6#include <vector>
7
8#include "barretenberg/aztec/aztec_constants.hpp"
9#include "barretenberg/vm2/common/aztec_types.hpp"
10#include "barretenberg/vm2/common/field.hpp"
11#include "barretenberg/vm2/constraining/flavor_settings.hpp"
12#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
13#include "barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp"
14#include "barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp"
15#include "barretenberg/vm2/simulation/events/contract_instance_retrieval_event.hpp"
16#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
17#include "barretenberg/vm2/testing/fixtures.hpp"
18#include "barretenberg/vm2/testing/macros.hpp"
19#include "barretenberg/vm2/testing/public_inputs_builder.hpp"
20#include "barretenberg/vm2/tracegen/contract_instance_retrieval_trace.hpp"
21#include "barretenberg/vm2/tracegen/precomputed_trace.hpp"
22#include "barretenberg/vm2/tracegen/public_inputs_trace.hpp"
23#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
24
25namespace bb::avm2::constraining {
26namespace {
27
28using simulation::ContractInstanceRetrievalEvent;
29using simulation::EventEmitter;
30using testing::PublicInputsBuilder;
31using tracegen::ContractInstanceRetrievalTraceBuilder;
32using tracegen::PrecomputedTraceBuilder;
33using tracegen::PublicInputsTraceBuilder;
34using tracegen::TestTraceContainer;
35using FF = AvmFlavorSettings::FF;
36using C = Column;
37using contract_instance_retrieval = bb::avm2::contract_instance_retrieval<FF>;
38
39// Helper to create a test contract instance
40ContractInstance create_test_contract_instance(uint32_t salt_value = 123)
41{
42 return ContractInstance{
43 .salt = FF(salt_value),
44 .deployer = FF(0x123456789ULL),
45 .current_contract_class_id = FF(0xdeadbeefULL),
46 .original_contract_class_id = FF(0xcafebabeULL),
47 .initialization_hash = FF(0x11111111ULL),
48 .immutables_hash = FF(0x22222222ULL),
49 .public_keys =
50 PublicKeys{
51 .nullifier_key_hash = FF(0x100),
52 .incoming_viewing_key = { FF(0x200), FF(0x201) },
53 .outgoing_viewing_key_hash = FF(0x300),
54 .tagging_key_hash = FF(0x400),
55 .message_signing_key_hash = FF(0x500),
56 .fallback_key_hash = FF(0x600),
57 },
58 };
59}
60
61TEST(ContractInstanceRetrievalConstrainingTest, EmptyRow)
62{
63 check_relation<contract_instance_retrieval>(testing::empty_trace());
64}
65
66TEST(ContractInstanceRetrievalConstrainingTest, CompleteValidTrace)
67{
68 // Test constants
69 const auto contract_address = FF(0x1234567890abcdefULL);
70 const auto nullifier_tree_root = FF(0xaabbccdd);
71 const auto public_data_tree_root = FF(0xeeff1122);
72 const auto exists = true;
73 const auto salt = FF(0x555);
74 const auto deployer_addr = FF(0x123456789ULL);
75 const auto current_class_id = FF(0xdeadbeefULL);
76 const auto original_class_id = FF(0xcafebabeULL);
77 const auto init_hash = FF(0x11111111ULL);
78 const auto immutables_hash = FF(0x22222222ULL);
79 const auto nullifier_key_hash = FF(0x100);
80 const auto incoming_viewing_key_x = FF(0x200);
81 const auto incoming_viewing_key_y = FF(0x201);
82 const auto outgoing_viewing_key_hash = FF(0x300);
83 const auto tagging_key_hash = FF(0x400);
84 const auto message_signing_key_hash = FF(0x500);
85 const auto fallback_key_hash = FF(0x600);
86
87 // Test complete valid trace with all constraints
88 TestTraceContainer trace({
89 { { C::precomputed_first_row, 1 } },
90 { { C::contract_instance_retrieval_sel, 1 },
91 { C::contract_instance_retrieval_address, contract_address },
92 { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
93 { C::contract_instance_retrieval_salt, salt },
94 { C::contract_instance_retrieval_deployer_addr, deployer_addr },
95 { C::contract_instance_retrieval_current_class_id, current_class_id },
96 { C::contract_instance_retrieval_original_class_id, original_class_id },
97 { C::contract_instance_retrieval_init_hash, init_hash },
98 { C::contract_instance_retrieval_immutables_hash, immutables_hash },
99 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
100 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
101 { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
102 { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
103 { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
104 { C::contract_instance_retrieval_nullifier_key_hash, nullifier_key_hash },
105 { C::contract_instance_retrieval_incoming_viewing_key_x, incoming_viewing_key_x },
106 { C::contract_instance_retrieval_incoming_viewing_key_y, incoming_viewing_key_y },
107 { C::contract_instance_retrieval_outgoing_viewing_key_hash, outgoing_viewing_key_hash },
108 { C::contract_instance_retrieval_tagging_key_hash, tagging_key_hash },
109 { C::contract_instance_retrieval_message_signing_key_hash, message_signing_key_hash },
110 { C::contract_instance_retrieval_fallback_key_hash, fallback_key_hash },
111 { C::contract_instance_retrieval_deployer_protocol_contract_address,
112 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
113 // Protocol Contract conditionals
114 { C::contract_instance_retrieval_address_sub_one, contract_address - 1 },
115 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
116 { C::contract_instance_retrieval_derived_address, contract_address },
117 { C::contract_instance_retrieval_is_protocol_contract, 0 },
118 { C::contract_instance_retrieval_should_check_nullifier, 1 },
119 { C::contract_instance_retrieval_should_check_for_update, 1 } },
120 });
121
122 check_relation<contract_instance_retrieval>(trace);
123}
124
125TEST(ContractInstanceRetrievalConstrainingTest, MultipleInstancesTrace)
126{
127 // Test constants
128 const auto num_instances = 3;
129 const auto base_address = 0x1000;
130 const auto base_nullifier_tree_root = 0x2000;
131 const auto base_public_data_tree_root = 0x3000;
132 const auto base_salt = 100;
133
134 // Test multiple contract instances in sequence
135 std::vector<std::vector<std::pair<C, FF>>> trace_data;
136
137 // First row
138 trace_data.push_back({ { C::precomputed_first_row, 1 } });
139
140 // Create multiple instance rows
141 for (uint32_t i = 0; i < num_instances; i++) {
142 auto contract_instance = create_test_contract_instance(base_salt + i);
143
144 trace_data.push_back({
145 { C::contract_instance_retrieval_sel, 1 },
146 { C::contract_instance_retrieval_address, FF(base_address + i) },
147 { C::contract_instance_retrieval_exists, 1 },
148 { C::contract_instance_retrieval_salt, contract_instance.salt },
149 { C::contract_instance_retrieval_deployer_addr, contract_instance.deployer },
150 { C::contract_instance_retrieval_current_class_id, contract_instance.current_contract_class_id },
151 { C::contract_instance_retrieval_original_class_id, contract_instance.original_contract_class_id },
152 { C::contract_instance_retrieval_init_hash, contract_instance.initialization_hash },
153 { C::contract_instance_retrieval_immutables_hash, contract_instance.immutables_hash },
154 { C::contract_instance_retrieval_public_data_tree_root, FF(base_public_data_tree_root + i) },
155 { C::contract_instance_retrieval_nullifier_tree_root, FF(base_nullifier_tree_root + i) },
156 { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
157 { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
158 { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
159 { C::contract_instance_retrieval_nullifier_key_hash, contract_instance.public_keys.nullifier_key_hash },
160 { C::contract_instance_retrieval_incoming_viewing_key_x,
161 contract_instance.public_keys.incoming_viewing_key.x },
162 { C::contract_instance_retrieval_incoming_viewing_key_y,
163 contract_instance.public_keys.incoming_viewing_key.y },
164 { C::contract_instance_retrieval_outgoing_viewing_key_hash,
165 contract_instance.public_keys.outgoing_viewing_key_hash },
166 { C::contract_instance_retrieval_tagging_key_hash, contract_instance.public_keys.tagging_key_hash },
167 { C::contract_instance_retrieval_message_signing_key_hash,
168 contract_instance.public_keys.message_signing_key_hash },
169 { C::contract_instance_retrieval_fallback_key_hash, contract_instance.public_keys.fallback_key_hash },
170 { C::contract_instance_retrieval_deployer_protocol_contract_address,
171 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
172 // Protocol Contract conditionals
173 { C::contract_instance_retrieval_address_sub_one, (base_address + i) - 1 },
174 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
175 { C::contract_instance_retrieval_derived_address, base_address + i },
176 { C::contract_instance_retrieval_is_protocol_contract, 0 },
177 { C::contract_instance_retrieval_should_check_nullifier, 1 },
178 { C::contract_instance_retrieval_should_check_for_update, 1 },
179 });
180 }
181
182 TestTraceContainer trace(trace_data);
183 check_relation<contract_instance_retrieval>(trace);
184}
185
186TEST(ContractInstanceRetrievalConstrainingTest, NonExistentInstanceTrace)
187{
188 // Test constants
189 const auto contract_address = FF(0x99999999);
190 const auto nullifier_tree_root = FF(0xffffff);
191 const auto public_data_tree_root = FF(0xeeeeee);
192 const auto exists = false;
193
194 // Test trace for non-existent contract instance
195 TestTraceContainer trace({
196 { { C::precomputed_first_row, 1 } },
197 { { C::contract_instance_retrieval_sel, 1 },
198 { C::contract_instance_retrieval_address, contract_address },
199 { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
200 { C::contract_instance_retrieval_salt, 0 },
201 { C::contract_instance_retrieval_deployer_addr, 0 },
202 { C::contract_instance_retrieval_current_class_id, 0 },
203 { C::contract_instance_retrieval_original_class_id, 0 },
204 { C::contract_instance_retrieval_init_hash, 0 },
205 { C::contract_instance_retrieval_immutables_hash, 0 },
206 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
207 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
208 { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
209 { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
210 { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
211 { C::contract_instance_retrieval_deployer_protocol_contract_address,
212 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
213 // Protocol Contract conditionals
214 { C::contract_instance_retrieval_address_sub_one, contract_address - 1 },
215 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
216 { C::contract_instance_retrieval_derived_address, contract_address },
217 { C::contract_instance_retrieval_is_protocol_contract, 0 },
218 { C::contract_instance_retrieval_should_check_nullifier, 1 },
219 { C::contract_instance_retrieval_should_check_for_update, 0 /*since exists = false*/ } },
220 });
221
222 check_relation<contract_instance_retrieval>(trace);
223
224 // mutate instance members to be nonzero and confirm that relation fails
225 // mutate deployer_addr
226 trace.set(C::contract_instance_retrieval_deployer_addr, 1, 1);
227 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
228 "INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE");
229 // reset
230 trace.set(C::contract_instance_retrieval_deployer_addr, 1, 0);
231 // mutate current_class_id
232 trace.set(C::contract_instance_retrieval_current_class_id, 1, 1);
233 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
234 "INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE");
235 // reset
236 trace.set(C::contract_instance_retrieval_current_class_id, 1, 0);
237 // mutate original_class_id
238 trace.set(C::contract_instance_retrieval_original_class_id, 1, 1);
239 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
240 "INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE");
241 // reset
242 trace.set(C::contract_instance_retrieval_original_class_id, 1, 0);
243 // mutate init_hash
244 trace.set(C::contract_instance_retrieval_init_hash, 1, 1);
245 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
246 "INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE");
247 // reset
248 trace.set(C::contract_instance_retrieval_init_hash, 1, 0);
249 // mutate immutables_hash
250 trace.set(C::contract_instance_retrieval_immutables_hash, 1, 1);
251 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
252 "INSTANCE_MEMBER_IMMUTABLES_HASH_IS_ZERO_IF_DNE");
253 // reset
254 trace.set(C::contract_instance_retrieval_immutables_hash, 1, 0);
255}
256
257TEST(ContractInstanceRetrievalConstrainingTest, MaximumFieldValuesTrace)
258{
259 // Test constants
260 const auto max_field = FF(-1); // Maximum field value
261
262 // Test trace with maximum field values
263 TestTraceContainer trace({
264 { { C::precomputed_first_row, 1 } },
265 { { C::contract_instance_retrieval_sel, 1 },
266 { C::contract_instance_retrieval_address, max_field },
267 { C::contract_instance_retrieval_exists, 1 },
268 { C::contract_instance_retrieval_salt, max_field },
269 { C::contract_instance_retrieval_deployer_addr, max_field },
270 { C::contract_instance_retrieval_current_class_id, max_field },
271 { C::contract_instance_retrieval_original_class_id, max_field },
272 { C::contract_instance_retrieval_init_hash, max_field },
273 { C::contract_instance_retrieval_immutables_hash, max_field },
274 { C::contract_instance_retrieval_public_data_tree_root, max_field },
275 { C::contract_instance_retrieval_nullifier_tree_root, max_field },
276 { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
277 { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
278 { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
279 { C::contract_instance_retrieval_nullifier_key_hash, max_field },
280 { C::contract_instance_retrieval_incoming_viewing_key_x, max_field },
281 { C::contract_instance_retrieval_incoming_viewing_key_y, max_field },
282 { C::contract_instance_retrieval_outgoing_viewing_key_hash, max_field },
283 { C::contract_instance_retrieval_tagging_key_hash, max_field },
284 { C::contract_instance_retrieval_message_signing_key_hash, max_field },
285 { C::contract_instance_retrieval_fallback_key_hash, max_field },
286 { C::contract_instance_retrieval_deployer_protocol_contract_address,
287 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
288 // Protocol Contract conditionals
289 { C::contract_instance_retrieval_address_sub_one, max_field - 1 },
290 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
291 { C::contract_instance_retrieval_derived_address, max_field },
292 { C::contract_instance_retrieval_is_protocol_contract, 0 },
293 { C::contract_instance_retrieval_should_check_nullifier, 1 },
294 { C::contract_instance_retrieval_should_check_for_update, 1 } },
295 });
296
297 check_relation<contract_instance_retrieval>(trace);
298}
299
300TEST(ContractInstanceRetrievalConstrainingTest, ProtocolContractInstanceExists)
301{
302 // Test constants
303 const AztecAddress contract_address = FEE_JUICE_ADDRESS;
304 const AztecAddress derived_address = FF(0xabcdef1234567890ULL);
305 const auto nullifier_tree_root = FF(0xbadc0ffeeULL);
306 const auto public_data_tree_root = FF(0xfacefeedUL);
307 ProtocolContracts protocol_contracts = {};
308 uint32_t protocol_contract_index = static_cast<uint32_t>(contract_address - 1);
309 protocol_contracts.derived_addresses[protocol_contract_index] = derived_address;
310
311 auto public_inputs = PublicInputsBuilder().set_protocol_contracts(protocol_contracts).build();
312
313 // Test complete valid trace with all constraints
314 TestTraceContainer trace({
315 {
316 { C::precomputed_first_row, 1 },
317 // Field Greater-Than Trace for Protocol Contract Address Check
318 { C::ff_gt_sel, 1 },
319 { C::ff_gt_sel_gt, 1 },
320 { C::ff_gt_a, MAX_PROTOCOL_CONTRACTS },
321 { C::ff_gt_b, contract_address - FF(1) },
322 { C::ff_gt_result, 1 },
323 },
324 {
325 // Contract Retrieval Instance Trace
326 { C::contract_instance_retrieval_sel, 1 },
327 { C::contract_instance_retrieval_address, contract_address },
328 { C::contract_instance_retrieval_exists, 1 },
329 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
330 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
331 { C::contract_instance_retrieval_deployer_protocol_contract_address,
332 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
333 // Protocol Contract conditionals
334 { C::contract_instance_retrieval_derived_address_pi_index,
335 AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX + protocol_contract_index },
336 { C::contract_instance_retrieval_protocol_contract_derived_address_inv, derived_address.invert() },
337 { C::contract_instance_retrieval_address_sub_one, contract_address - FF(1) },
338 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
339 { C::contract_instance_retrieval_derived_address, derived_address },
340 { C::contract_instance_retrieval_is_protocol_contract, 1 },
341 { C::contract_instance_retrieval_should_check_nullifier, 0 },
342 { C::contract_instance_retrieval_should_check_for_update, 0 },
343 },
344 });
345
346 PublicInputsTraceBuilder public_inputs_builder;
347 public_inputs_builder.process_public_inputs(trace, public_inputs);
348 public_inputs_builder.process_public_inputs_aux_precomputed(trace);
349
350 tracegen::PrecomputedTraceBuilder precomputed_builder;
351 precomputed_builder.process_misc(trace, trace.get_num_rows());
352
353 check_relation<contract_instance_retrieval>(trace);
354 check_interaction<ContractInstanceRetrievalTraceBuilder,
355 lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings,
356 lookup_contract_instance_retrieval_check_protocol_address_range_settings>(trace);
357}
358
359TEST(ContractInstanceRetrievalConstrainingTest, ProtocolContractInstanceNotExists)
360{
361 // Test constants
362 const AztecAddress contract_address = FEE_JUICE_ADDRESS;
363 const AztecAddress derived_address = FF(0);
364 const auto nullifier_tree_root = FF(0xbadc0ffeeULL);
365 const auto public_data_tree_root = FF(0xfacefeedUL);
366 uint32_t protocol_contract_index = static_cast<uint32_t>(contract_address - 1);
367 // Default protocol contracts: empty
368 auto public_inputs = PublicInputsBuilder().build();
369
370 // Test complete valid trace with all constraints
371 TestTraceContainer trace({
372 {
373 { C::precomputed_first_row, 1 },
374 // Field Greater-Than Trace for Protocol Contract Address Check
375 { C::ff_gt_sel, 1 },
376 { C::ff_gt_sel_gt, 1 },
377 { C::ff_gt_a, MAX_PROTOCOL_CONTRACTS },
378 { C::ff_gt_b, contract_address - FF(1) },
379 { C::ff_gt_result, 1 },
380 },
381 {
382 // Contract Retrieval Instance Trace
383 { C::contract_instance_retrieval_sel, 1 },
384 { C::contract_instance_retrieval_address, contract_address },
385 { C::contract_instance_retrieval_exists, 0 },
386 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
387 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
388 { C::contract_instance_retrieval_deployer_protocol_contract_address,
389 CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
390 // Protocol Contract conditionals
391 { C::contract_instance_retrieval_derived_address_pi_index,
392 AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX + protocol_contract_index },
393 { C::contract_instance_retrieval_protocol_contract_derived_address_inv, 0 },
394 { C::contract_instance_retrieval_address_sub_one, contract_address - FF(1) },
395 { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
396 { C::contract_instance_retrieval_derived_address, derived_address },
397 { C::contract_instance_retrieval_is_protocol_contract, 1 },
398 { C::contract_instance_retrieval_should_check_nullifier, 0 },
399 { C::contract_instance_retrieval_should_check_for_update, 0 },
400 },
401 });
402
403 PublicInputsTraceBuilder public_inputs_builder;
404 public_inputs_builder.process_public_inputs(trace, public_inputs);
405 public_inputs_builder.process_public_inputs_aux_precomputed(trace);
406
407 tracegen::PrecomputedTraceBuilder precomputed_builder;
408 precomputed_builder.process_misc(trace, trace.get_num_rows());
409
410 check_relation<contract_instance_retrieval>(trace);
411 check_interaction<ContractInstanceRetrievalTraceBuilder,
412 lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings,
413 lookup_contract_instance_retrieval_check_protocol_address_range_settings>(trace);
414}
415
416// Integration-style tests using tracegen components
417TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenValidInstance)
418{
419 // Test constants
420 const auto contract_address = FF(0x1234567890abcdefULL);
421 const auto timestamp = 12345;
422 const auto nullifier_tree_root = FF(0xaabbccdd);
423 const auto public_data_tree_root = FF(0xeeff1122);
424 const auto deployment_nullifier = FF(0x7777);
425
426 // Use real tracegen to generate a valid trace
427 EventEmitter<ContractInstanceRetrievalEvent> emitter;
428 auto contract_instance = create_test_contract_instance();
429
430 ContractInstanceRetrievalEvent event = { .address = contract_address,
431 .contract_instance = contract_instance,
432 .nullifier_tree_root = nullifier_tree_root,
433 .public_data_tree_root = public_data_tree_root,
434 .deployment_nullifier = deployment_nullifier,
435 .exists = true,
436 .is_protocol_contract = false };
437
438 emitter.emit(std::move(event));
439 auto events = emitter.dump_events();
440
441 TestTraceContainer trace;
442 ContractInstanceRetrievalTraceBuilder builder;
443 builder.process(events, trace);
444
445 // Add precomputed table entries
446 PrecomputedTraceBuilder precomputed_builder;
447 precomputed_builder.process_misc(trace, trace.get_num_rows());
448 precomputed_builder.process_get_contract_instance_table(trace);
449 precomputed_builder.process_sel_range_8(trace);
450
451 // Manually populate destination tables for lookup interactions
452 auto contract_instance_data = create_test_contract_instance();
453
454 trace.set(
455 1,
456 { { // For deployment nullifier lookup
457 { C::indexed_tree_check_sel, 1 },
458 { C::indexed_tree_check_exists, 1 },
459 { C::indexed_tree_check_value, contract_address },
460 { C::indexed_tree_check_root, nullifier_tree_root },
461 { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
462 { C::indexed_tree_check_sel_silo, 1 },
463 { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
464 { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
465 { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
466 // For address derivation lookup
467 { C::address_derivation_sel, 1 },
468 { C::address_derivation_address, contract_address },
469 { C::address_derivation_salt, contract_instance_data.salt },
470 { C::address_derivation_deployer_addr, contract_instance_data.deployer },
471 { C::address_derivation_class_id, contract_instance_data.original_contract_class_id },
472 { C::address_derivation_init_hash, contract_instance_data.initialization_hash },
473 { C::address_derivation_immutables_hash, contract_instance_data.immutables_hash },
474 { C::address_derivation_nullifier_key_hash, contract_instance_data.public_keys.nullifier_key_hash },
475 { C::address_derivation_incoming_viewing_key_x, contract_instance_data.public_keys.incoming_viewing_key.x },
476 { C::address_derivation_incoming_viewing_key_y, contract_instance_data.public_keys.incoming_viewing_key.y },
477 { C::address_derivation_outgoing_viewing_key_hash,
478 contract_instance_data.public_keys.outgoing_viewing_key_hash },
479 { C::address_derivation_tagging_key_hash, contract_instance_data.public_keys.tagging_key_hash },
480 { C::address_derivation_message_signing_key_hash,
481 contract_instance_data.public_keys.message_signing_key_hash },
482 { C::address_derivation_fallback_key_hash, contract_instance_data.public_keys.fallback_key_hash },
483 // For update check lookup
484 { C::update_check_sel, 1 },
485 { C::update_check_address, contract_address },
486 { C::update_check_current_class_id, contract_instance_data.current_contract_class_id },
487 { C::update_check_original_class_id, contract_instance_data.original_contract_class_id },
488 { C::update_check_public_data_tree_root, public_data_tree_root },
489 { C::update_check_timestamp, timestamp },
490 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
491
492 check_relation<contract_instance_retrieval>(trace);
493
494 // Test lookup interactions
495 check_interaction<ContractInstanceRetrievalTraceBuilder,
496 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
497 check_interaction<ContractInstanceRetrievalTraceBuilder,
498 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
499 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
500 trace);
501}
502
503TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenNonExistentInstance)
504{
505 // Test constants
506 const auto contract_address = FF(0x999999999ULL);
507 const auto timestamp = 99999;
508 const auto nullifier_tree_root = FF(0xffffff);
509 const auto public_data_tree_root = FF(0xeeeeee);
510 const auto deployment_nullifier = FF(0x8888);
511
512 // Use real tracegen to generate a valid trace for non-existent instance
513 EventEmitter<ContractInstanceRetrievalEvent> emitter;
514
515 ContractInstanceRetrievalEvent event{ .address = contract_address,
516 .contract_instance = {}, // no instance, DNE
517 .nullifier_tree_root = nullifier_tree_root,
518 .public_data_tree_root = public_data_tree_root,
519 .deployment_nullifier = deployment_nullifier,
520 .exists = false, // Non-existent
521 .is_protocol_contract = false };
522
523 emitter.emit(std::move(event));
524 auto events = emitter.dump_events();
525
526 TestTraceContainer trace;
527 ContractInstanceRetrievalTraceBuilder builder;
528 builder.process(events, trace);
529
530 // Add precomputed table entries
531 PrecomputedTraceBuilder precomputed_builder;
532 precomputed_builder.process_misc(trace, trace.get_num_rows());
533 precomputed_builder.process_get_contract_instance_table(trace);
534 precomputed_builder.process_sel_range_8(trace);
535
536 trace.set(1,
537 { { // For deployment nullifier read lookup
538 { C::indexed_tree_check_sel, 1 },
539 { C::indexed_tree_check_exists, 0 }, // Non-existent
540 { C::indexed_tree_check_value, contract_address },
541 { C::indexed_tree_check_root, nullifier_tree_root },
542 { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
543 { C::indexed_tree_check_sel_silo, 1 },
544 { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
545 { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
546 { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
547 // For address derivation lookup
548 { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist
549 { C::address_derivation_address, contract_address },
550 { C::address_derivation_salt, 0 }, // zero since nullifier doesn't exist
551 { C::address_derivation_deployer_addr, 0 }, // zero since nullifier doesn't exist
552 { C::address_derivation_class_id, 0 }, // zero since nullifier doesn't exist
553 { C::address_derivation_init_hash, 0 }, // zero since nullifier doesn't exist
554 { C::address_derivation_immutables_hash, 0 }, // zero since nullifier doesn't exist
555 { C::address_derivation_nullifier_key_hash, 0 },
556 { C::address_derivation_incoming_viewing_key_x, 0 },
557 { C::address_derivation_incoming_viewing_key_y, 0 },
558 { C::address_derivation_outgoing_viewing_key_hash, 0 },
559 { C::address_derivation_tagging_key_hash, 0 },
560 { C::address_derivation_message_signing_key_hash, 0 },
561 { C::address_derivation_fallback_key_hash, 0 },
562 // For update check lookup (only populated when nullifier exists)
563 { C::update_check_sel, 0 }, // Not selected since nullifier doesn't exist
564 { C::update_check_address, contract_address },
565 { C::update_check_current_class_id, 0 },
566 { C::update_check_original_class_id, 0 },
567 { C::update_check_public_data_tree_root, public_data_tree_root },
568 { C::update_check_timestamp, timestamp },
569 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
570
571 check_relation<contract_instance_retrieval>(trace);
572
573 // Test lookup interactions
574 check_interaction<ContractInstanceRetrievalTraceBuilder,
575 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
576 check_interaction<ContractInstanceRetrievalTraceBuilder,
577 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
578 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
579 trace);
580}
581
582TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenAddressZero)
583{
584 // Test constants
585 const auto contract_address = FF(0);
586 const auto timestamp = 99999;
587 const auto nullifier_tree_root = FF(0xffffff);
588 const auto public_data_tree_root = FF(0xeeeeee);
589 const auto deployment_nullifier = FF(0x8888);
590
591 // Use real tracegen to generate a valid trace for non-existent instance
592 EventEmitter<ContractInstanceRetrievalEvent> emitter;
593
594 ContractInstanceRetrievalEvent event{
595 .address = contract_address,
596 .contract_instance = {}, // no instance, DNE
597 .nullifier_tree_root = nullifier_tree_root,
598 .public_data_tree_root = public_data_tree_root,
599 .deployment_nullifier = deployment_nullifier,
600 .exists = false, // Non-existent
601 .is_protocol_contract = false, // Not a protocol contract, since MAX_PROTOCOL_CONTRACTS < (0 - 1)
602 };
603
604 emitter.emit(std::move(event));
605 auto events = emitter.dump_events();
606
607 TestTraceContainer trace;
608 ContractInstanceRetrievalTraceBuilder builder;
609 builder.process(events, trace);
610
611 // Add precomputed table entries
612 PrecomputedTraceBuilder precomputed_builder;
613 precomputed_builder.process_misc(trace, trace.get_num_rows());
614 precomputed_builder.process_get_contract_instance_table(trace);
615 precomputed_builder.process_sel_range_8(trace);
616
617 trace.set(1,
618 { { // For deployment nullifier read lookup
619 { C::indexed_tree_check_sel, 1 },
620 { C::indexed_tree_check_exists, 0 }, // Non-existent
621 { C::indexed_tree_check_value, contract_address },
622 { C::indexed_tree_check_root, nullifier_tree_root },
623 { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
624 { C::indexed_tree_check_sel_silo, 1 },
625 { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
626 { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
627 { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
628 // For address derivation lookup
629 { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist
630 { C::address_derivation_address, contract_address },
631 { C::address_derivation_salt, 0 }, // zero since nullifier doesn't exist
632 { C::address_derivation_deployer_addr, 0 }, // zero since nullifier doesn't exist
633 { C::address_derivation_class_id, 0 }, // zero since nullifier doesn't exist
634 { C::address_derivation_init_hash, 0 }, // zero since nullifier doesn't exist
635 { C::address_derivation_immutables_hash, 0 }, // zero since nullifier doesn't exist
636 { C::address_derivation_nullifier_key_hash, 0 },
637 { C::address_derivation_incoming_viewing_key_x, 0 },
638 { C::address_derivation_incoming_viewing_key_y, 0 },
639 { C::address_derivation_outgoing_viewing_key_hash, 0 },
640 { C::address_derivation_tagging_key_hash, 0 },
641 { C::address_derivation_message_signing_key_hash, 0 },
642 { C::address_derivation_fallback_key_hash, 0 },
643 // For update check lookup (only populated when nullifier exists)
644 { C::update_check_sel, 0 }, // Not selected since nullifier doesn't exist
645 { C::update_check_address, contract_address },
646 { C::update_check_current_class_id, 0 },
647 { C::update_check_original_class_id, 0 },
648 { C::update_check_public_data_tree_root, public_data_tree_root },
649 { C::update_check_timestamp, timestamp },
650 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
651
652 check_relation<contract_instance_retrieval>(trace);
653
654 // Test lookup interactions
655 check_interaction<ContractInstanceRetrievalTraceBuilder,
656 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
657 check_interaction<ContractInstanceRetrievalTraceBuilder,
658 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
659 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
660 trace);
661}
662
663TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenMultipleInstances)
664{
665 // Test constants
666 const auto num_instances = 3;
667 const auto base_address = 0x1000;
668 const auto base_timestamp = 1000;
669 const auto base_nullifier_tree_root = 0x2000;
670 const auto base_public_data_tree_root = 0x3000;
671 const auto base_salt = 100;
672
673 // Use real tracegen to generate multiple instances
674 EventEmitter<ContractInstanceRetrievalEvent> emitter;
675
676 for (uint32_t i = 0; i < num_instances; i++) {
677 auto contract_instance = create_test_contract_instance(base_salt + i);
678
679 ContractInstanceRetrievalEvent event = { .address = FF(base_address + i),
680 .contract_instance = contract_instance,
681 .nullifier_tree_root = FF(base_nullifier_tree_root + i),
682 .public_data_tree_root = FF(base_public_data_tree_root + i),
683 .deployment_nullifier = FF(base_address + i),
684 .exists = true,
685 .is_protocol_contract = false };
686
687 emitter.emit(std::move(event));
688 }
689
690 auto events = emitter.dump_events();
691
692 TestTraceContainer trace;
693 ContractInstanceRetrievalTraceBuilder builder;
694 builder.process(events, trace);
695
696 // Add precomputed table entries
697 PrecomputedTraceBuilder precomputed_builder;
698 precomputed_builder.process_misc(trace, trace.get_num_rows());
699 precomputed_builder.process_get_contract_instance_table(trace);
700 precomputed_builder.process_sel_range_8(trace);
701
702 // Manually populate destination tables for lookup interactions
703 for (uint32_t i = 0; i < num_instances; i++) {
704 auto contract_instance_data = create_test_contract_instance(base_salt + i);
705 uint32_t row = i + 1; // Skip row 0 (skippable gadget)
706
707 trace.set(
708 row, // For deployment nullifier read lookup
709 { { { C::indexed_tree_check_sel, 1 },
710 { C::indexed_tree_check_exists, true },
711 { C::indexed_tree_check_value, FF(base_address + i) },
712 { C::indexed_tree_check_root, FF(base_nullifier_tree_root + i) },
713 { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
714 { C::indexed_tree_check_sel_silo, 1 },
715 { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
716 { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
717 { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
718 // For address derivation lookup (only when nullifier exists)
719 { C::address_derivation_sel, 1 },
720 { C::address_derivation_address, FF(base_address + i) },
721 { C::address_derivation_salt, contract_instance_data.salt },
722 { C::address_derivation_deployer_addr, contract_instance_data.deployer },
723 { C::address_derivation_class_id, contract_instance_data.original_contract_class_id },
724 { C::address_derivation_init_hash, contract_instance_data.initialization_hash },
725 { C::address_derivation_immutables_hash, contract_instance_data.immutables_hash },
726 { C::address_derivation_nullifier_key_hash, contract_instance_data.public_keys.nullifier_key_hash },
727 { C::address_derivation_incoming_viewing_key_x,
728 contract_instance_data.public_keys.incoming_viewing_key.x },
729 { C::address_derivation_incoming_viewing_key_y,
730 contract_instance_data.public_keys.incoming_viewing_key.y },
731 { C::address_derivation_outgoing_viewing_key_hash,
732 contract_instance_data.public_keys.outgoing_viewing_key_hash },
733 { C::address_derivation_tagging_key_hash, contract_instance_data.public_keys.tagging_key_hash },
734 { C::address_derivation_message_signing_key_hash,
735 contract_instance_data.public_keys.message_signing_key_hash },
736 { C::address_derivation_fallback_key_hash, contract_instance_data.public_keys.fallback_key_hash },
737 // For update check lookup (only when nullifier exists)
738 { C::update_check_sel, 1 },
739 { C::update_check_address, FF(base_address + i) },
740 { C::update_check_current_class_id, contract_instance_data.current_contract_class_id },
741 { C::update_check_original_class_id, contract_instance_data.original_contract_class_id },
742 { C::update_check_public_data_tree_root, FF(base_public_data_tree_root + i) },
743 { C::update_check_timestamp, base_timestamp + i },
744 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
745 }
746
747 check_relation<contract_instance_retrieval>(trace);
748
749 // Test lookup interactions
750 check_interaction<ContractInstanceRetrievalTraceBuilder,
751 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
752 check_interaction<ContractInstanceRetrievalTraceBuilder,
753 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
754 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
755 trace);
756}
757
758} // namespace
759} // namespace bb::avm2::constraining
EXPECT_THROW_WITH_MESSAGE
#define EXPECT_THROW_WITH_MESSAGE(code, expectedMessageRegex)
Definition assert.hpp:193
aztec_constants.hpp
AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX
#define AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX
Definition aztec_constants.hpp:117
FEE_JUICE_ADDRESS
#define FEE_JUICE_ADDRESS
Definition aztec_constants.hpp:26
DOM_SEP__SILOED_NULLIFIER
#define DOM_SEP__SILOED_NULLIFIER
Definition aztec_constants.hpp:260
NULLIFIER_TREE_HEIGHT
#define NULLIFIER_TREE_HEIGHT
Definition aztec_constants.hpp:9
MAX_PROTOCOL_CONTRACTS
#define MAX_PROTOCOL_CONTRACTS
Definition aztec_constants.hpp:23
DOM_SEP__NULLIFIER_MERKLE
#define DOM_SEP__NULLIFIER_MERKLE
Definition aztec_constants.hpp:264
AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX
#define AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX
Definition aztec_constants.hpp:113
CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS
#define CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS
Definition aztec_constants.hpp:25
aztec_types.hpp
check_relation.hpp
bb::avm2::contract_instance_retrieval
Definition contract_instance_retrieval.hpp:34
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::PrecomputedTraceBuilder::process_misc
void process_misc(TraceContainer &trace, const uint32_t num_rows=PRECOMPUTED_TRACE_SIZE)
Populate miscellaneous precomputed columns: first_row selector and idx (row index).
Definition precomputed_trace.cpp:30
bb::avm2::tracegen::PrecomputedTraceBuilder::process_get_contract_instance_table
void process_get_contract_instance_table(TraceContainer &trace)
Populate the GETCONTRACTINSTANCE lookup table.
Definition precomputed_trace.cpp:473
bb::avm2::tracegen::PrecomputedTraceBuilder::process_sel_range_8
void process_sel_range_8(TraceContainer &trace)
Generate a selector column that activates the first 2^8 (256) rows.
Definition precomputed_trace.cpp:83
bb::avm2::tracegen::TraceContainer::set
void set(Column col, uint32_t row, const FF &value)
Definition trace_container.cpp:39
precomputed_builder
PrecomputedTraceBuilder precomputed_builder
Definition alu.test.cpp:120
builder
AluTraceBuilder builder
Definition alu.test.cpp:124
trace
TestTraceContainer trace
Definition data_copy.test.cpp:63
exists
bool exists
Definition indexed_tree_check.test.cpp:70
contract_instance_retrieval.hpp
contract_instance_retrieval_event.hpp
contract_instance_retrieval_trace.hpp
event_emitter.hpp
flavor_settings.hpp
lookups_contract_instance_retrieval.hpp
bb::avm2::constraining::check_interaction
void check_interaction(tracegen::TestTraceContainer &trace)
Definition check_relation.hpp:77
bb::avm2::constraining::TEST
TEST(AvmFixedVKTests, FixedVKCommitments)
Test that the fixed VK commitments agree with the ones computed from precomputed columns.
Definition avm_fixed_vk.test.cpp:52
bb::avm2::testing::empty_trace
TestTraceContainer empty_trace()
Definition fixtures.cpp:153
bb::avm2::lookup_contract_instance_retrieval_check_protocol_address_range_settings
lookup_settings< lookup_contract_instance_retrieval_check_protocol_address_range_settings_ > lookup_contract_instance_retrieval_check_protocol_address_range_settings
Definition lookups_contract_instance_retrieval.hpp:35
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::avm2::lookup_contract_instance_retrieval_address_derivation_settings
lookup_settings< lookup_contract_instance_retrieval_address_derivation_settings_ > lookup_contract_instance_retrieval_address_derivation_settings
Definition lookups_contract_instance_retrieval.hpp:149
bb::avm2::lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings
lookup_settings< lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings_ > lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings
Definition lookups_contract_instance_retrieval.hpp:63
bb::avm2::lookup_contract_instance_retrieval_deployment_nullifier_read_settings
lookup_settings< lookup_contract_instance_retrieval_deployment_nullifier_read_settings_ > lookup_contract_instance_retrieval_deployment_nullifier_read_settings
Definition lookups_contract_instance_retrieval.hpp:101
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
precomputed_trace.hpp
event
simulation::PublicDataTreeReadWriteEvent event
Definition public_data_tree_trace.cpp:33
public_inputs_trace.hpp
original_class_id
FF original_class_id
Definition update_check.test.cpp:91
current_class_id
FF current_class_id
Definition update_check.test.cpp:92
bb::field::invert
constexpr field invert() const noexcept
Definition field_impl.hpp:388
test_trace_container.hpp
public_inputs_builder.hpp
public_inputs_builder
tracegen::PublicInputsTraceBuilder public_inputs_builder
Definition tx.test.cpp:81