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