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/tracegen/contract_instance_retrieval_trace.hpp"
20#include "barretenberg/vm2/tracegen/precomputed_trace.hpp"
21#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
22
23namespace bb::avm2::constraining {
24namespace {
25
26using simulation::ContractInstanceRetrievalEvent;
27using simulation::EventEmitter;
28using tracegen::ContractInstanceRetrievalTraceBuilder;
29using tracegen::PrecomputedTraceBuilder;
30using tracegen::TestTraceContainer;
31using FF = AvmFlavorSettings::FF;
32using C = Column;
33using contract_instance_retrieval = bb::avm2::contract_instance_retrieval<FF>;
34
35// Helper to create a test contract instance
36ContractInstance create_test_contract_instance(uint32_t salt_value = 123)
37{
38 return ContractInstance{
39 .salt = FF(salt_value),
40 .deployer_addr = FF(0x123456789ULL),
41 .current_class_id = FF(0xdeadbeefULL),
42 .original_class_id = FF(0xcafebabeULL),
43 .initialisation_hash = FF(0x11111111ULL),
44 .public_keys =
45 PublicKeys{
46 .nullifier_key = { FF(0x100), FF(0x101) },
47 .incoming_viewing_key = { FF(0x200), FF(0x201) },
48 .outgoing_viewing_key = { FF(0x300), FF(0x301) },
49 .tagging_key = { FF(0x400), FF(0x401) },
50 },
51 };
52}
53
54TEST(ContractInstanceRetrievalConstrainingTest, EmptyRow)
55{
56 check_relation<contract_instance_retrieval>(testing::empty_trace());
57}
58
59TEST(ContractInstanceRetrievalConstrainingTest, CompleteValidTrace)
60{
61 // Test constants
62 const auto contract_address = FF(0x1234567890abcdefULL);
63 const auto nullifier_tree_root = FF(0xaabbccdd);
64 const auto public_data_tree_root = FF(0xeeff1122);
65 const auto deployer_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
66 const auto exists = true;
67 const auto salt = FF(0x555);
68 const auto deployer_addr = FF(0x123456789ULL);
69 const auto current_class_id = FF(0xdeadbeefULL);
70 const auto original_class_id = FF(0xcafebabeULL);
71 const auto init_hash = FF(0x11111111ULL);
72 const auto nullifier_key_x = FF(0x100);
73 const auto nullifier_key_y = FF(0x101);
74 const auto incoming_viewing_key_x = FF(0x200);
75 const auto incoming_viewing_key_y = FF(0x201);
76 const auto outgoing_viewing_key_x = FF(0x300);
77 const auto outgoing_viewing_key_y = FF(0x301);
78 const auto tagging_key_x = FF(0x400);
79 const auto tagging_key_y = FF(0x401);
80
81 // Test complete valid trace with all constraints
82 TestTraceContainer trace({
83 { { C::precomputed_first_row, 1 } },
84 { { C::contract_instance_retrieval_sel, 1 },
85 { C::contract_instance_retrieval_address, contract_address },
86 { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
87 { C::contract_instance_retrieval_salt, salt },
88 { C::contract_instance_retrieval_deployer_addr, deployer_addr },
89 { C::contract_instance_retrieval_current_class_id, current_class_id },
90 { C::contract_instance_retrieval_original_class_id, original_class_id },
91 { C::contract_instance_retrieval_init_hash, init_hash },
92 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
93 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
94 { C::contract_instance_retrieval_nullifier_key_x, nullifier_key_x },
95 { C::contract_instance_retrieval_nullifier_key_y, nullifier_key_y },
96 { C::contract_instance_retrieval_incoming_viewing_key_x, incoming_viewing_key_x },
97 { C::contract_instance_retrieval_incoming_viewing_key_y, incoming_viewing_key_y },
98 { C::contract_instance_retrieval_outgoing_viewing_key_x, outgoing_viewing_key_x },
99 { C::contract_instance_retrieval_outgoing_viewing_key_y, outgoing_viewing_key_y },
100 { C::contract_instance_retrieval_tagging_key_x, tagging_key_x },
101 { C::contract_instance_retrieval_tagging_key_y, tagging_key_y },
102 { C::contract_instance_retrieval_deployer_protocol_contract_address, deployer_contract_address } },
103 });
104
105 check_relation<contract_instance_retrieval>(trace);
106}
107
108TEST(ContractInstanceRetrievalConstrainingTest, MultipleInstancesTrace)
109{
110 // Test constants
111 const auto num_instances = 3;
112 const auto base_address = 0x1000;
113 const auto base_nullifier_tree_root = 0x2000;
114 const auto base_public_data_tree_root = 0x3000;
115 const auto base_salt = 100;
116 const auto deployer_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
117
118 // Test multiple contract instances in sequence
119 std::vector<std::vector<std::pair<C, FF>>> trace_data;
120
121 // First row
122 trace_data.push_back({ { C::precomputed_first_row, 1 } });
123
124 // Create multiple instance rows
125 for (uint32_t i = 0; i < num_instances; i++) {
126 auto contract_instance = create_test_contract_instance(base_salt + i);
127
128 trace_data.push_back({
129 { C::contract_instance_retrieval_sel, 1 },
130 { C::contract_instance_retrieval_address, FF(base_address + i) },
131 { C::contract_instance_retrieval_exists, 1 },
132 { C::contract_instance_retrieval_salt, contract_instance.salt },
133 { C::contract_instance_retrieval_deployer_addr, contract_instance.deployer_addr },
134 { C::contract_instance_retrieval_current_class_id, contract_instance.current_class_id },
135 { C::contract_instance_retrieval_original_class_id, contract_instance.original_class_id },
136 { C::contract_instance_retrieval_init_hash, contract_instance.initialisation_hash },
137 { C::contract_instance_retrieval_public_data_tree_root, FF(base_public_data_tree_root + i) },
138 { C::contract_instance_retrieval_nullifier_tree_root, FF(base_nullifier_tree_root + i) },
139 { C::contract_instance_retrieval_nullifier_key_x, contract_instance.public_keys.nullifier_key.x },
140 { C::contract_instance_retrieval_nullifier_key_y, contract_instance.public_keys.nullifier_key.y },
141 { C::contract_instance_retrieval_incoming_viewing_key_x,
142 contract_instance.public_keys.incoming_viewing_key.x },
143 { C::contract_instance_retrieval_incoming_viewing_key_y,
144 contract_instance.public_keys.incoming_viewing_key.y },
145 { C::contract_instance_retrieval_outgoing_viewing_key_x,
146 contract_instance.public_keys.outgoing_viewing_key.x },
147 { C::contract_instance_retrieval_outgoing_viewing_key_y,
148 contract_instance.public_keys.outgoing_viewing_key.y },
149 { C::contract_instance_retrieval_tagging_key_x, contract_instance.public_keys.tagging_key.x },
150 { C::contract_instance_retrieval_tagging_key_y, contract_instance.public_keys.tagging_key.y },
151 { C::contract_instance_retrieval_deployer_protocol_contract_address, deployer_contract_address },
152 });
153 }
154
155 TestTraceContainer trace(trace_data);
156 check_relation<contract_instance_retrieval>(trace);
157}
158
159TEST(ContractInstanceRetrievalConstrainingTest, NonExistentInstanceTrace)
160{
161 // Test constants
162 const auto contract_address = FF(0x99999999);
163 const auto nullifier_tree_root = FF(0xffffff);
164 const auto public_data_tree_root = FF(0xeeeeee);
165 const auto deployer_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
166 const auto exists = false;
167
168 // Test trace for non-existent contract instance
169 TestTraceContainer trace({
170 { { C::precomputed_first_row, 1 } },
171 { { C::contract_instance_retrieval_sel, 1 },
172 { C::contract_instance_retrieval_address, contract_address },
173 { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
174 { C::contract_instance_retrieval_salt, 0 },
175 { C::contract_instance_retrieval_deployer_addr, 0 },
176 { C::contract_instance_retrieval_current_class_id, 0 },
177 { C::contract_instance_retrieval_original_class_id, 0 },
178 { C::contract_instance_retrieval_init_hash, 0 },
179 { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
180 { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
181 { C::contract_instance_retrieval_deployer_protocol_contract_address, deployer_contract_address } },
182 });
183
184 check_relation<contract_instance_retrieval>(trace);
185
186 // mutate instance members to be nonzero and confirm that relation fails
187 // mutate deployer_addr
188 trace.set(C::contract_instance_retrieval_deployer_addr, 1, 1);
189 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
190 "INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE");
191 // reset
192 trace.set(C::contract_instance_retrieval_deployer_addr, 1, 0);
193 // mutate current_class_id
194 trace.set(C::contract_instance_retrieval_current_class_id, 1, 1);
195 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
196 "INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE");
197 // reset
198 trace.set(C::contract_instance_retrieval_current_class_id, 1, 0);
199 // mutate original_class_id
200 trace.set(C::contract_instance_retrieval_original_class_id, 1, 1);
201 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
202 "INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE");
203 // reset
204 trace.set(C::contract_instance_retrieval_original_class_id, 1, 0);
205 // mutate init_hash
206 trace.set(C::contract_instance_retrieval_init_hash, 1, 1);
207 EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
208 "INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE");
209 // reset
210 trace.set(C::contract_instance_retrieval_init_hash, 1, 0);
211}
212
213TEST(ContractInstanceRetrievalConstrainingTest, MaximumFieldValuesTrace)
214{
215 // Test constants
216 const auto max_field = FF(-1); // Maximum field value
217 const auto deployer_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
218
219 // Test trace with maximum field values
220 TestTraceContainer trace({
221 { { C::precomputed_first_row, 1 } },
222 { { C::contract_instance_retrieval_sel, 1 },
223 { C::contract_instance_retrieval_address, max_field },
224 { C::contract_instance_retrieval_exists, 1 },
225 { C::contract_instance_retrieval_salt, max_field },
226 { C::contract_instance_retrieval_deployer_addr, max_field },
227 { C::contract_instance_retrieval_current_class_id, max_field },
228 { C::contract_instance_retrieval_original_class_id, max_field },
229 { C::contract_instance_retrieval_init_hash, max_field },
230 { C::contract_instance_retrieval_public_data_tree_root, max_field },
231 { C::contract_instance_retrieval_nullifier_tree_root, max_field },
232 { C::contract_instance_retrieval_nullifier_key_x, max_field },
233 { C::contract_instance_retrieval_nullifier_key_y, max_field },
234 { C::contract_instance_retrieval_incoming_viewing_key_x, max_field },
235 { C::contract_instance_retrieval_incoming_viewing_key_y, max_field },
236 { C::contract_instance_retrieval_outgoing_viewing_key_x, max_field },
237 { C::contract_instance_retrieval_outgoing_viewing_key_y, max_field },
238 { C::contract_instance_retrieval_tagging_key_x, max_field },
239 { C::contract_instance_retrieval_tagging_key_y, max_field },
240 { C::contract_instance_retrieval_deployer_protocol_contract_address, deployer_contract_address } },
241 });
242
243 check_relation<contract_instance_retrieval>(trace);
244}
245
246// Integration-style tests using tracegen components
247TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenValidInstance)
248{
249 // Test constants
250 const auto contract_address = FF(0x1234567890abcdefULL);
251 const auto timestamp = 12345;
252 const auto nullifier_tree_root = FF(0xaabbccdd);
253 const auto public_data_tree_root = FF(0xeeff1122);
254 const auto deployment_nullifier = FF(0x7777);
255 const auto deployer_protocol_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
256
257 // Use real tracegen to generate a valid trace
258 EventEmitter<ContractInstanceRetrievalEvent> emitter;
259 auto contract_instance = create_test_contract_instance();
260
261 ContractInstanceRetrievalEvent event = { .address = contract_address,
262 .contract_instance = contract_instance,
263 .nullifier_tree_root = nullifier_tree_root,
264 .public_data_tree_root = public_data_tree_root,
265 .deployment_nullifier = deployment_nullifier,
266 .nullifier_exists = true,
267 .deployer_protocol_contract_address = deployer_protocol_contract_address,
268 .error = false };
269
270 emitter.emit(std::move(event));
271 auto events = emitter.dump_events();
272
273 TestTraceContainer trace;
274 ContractInstanceRetrievalTraceBuilder builder;
275 builder.process(events, trace);
276
277 // Add precomputed table entries
278 PrecomputedTraceBuilder precomputed_builder;
279 precomputed_builder.process_misc(trace, trace.get_num_rows());
280 precomputed_builder.process_get_contract_instance_table(trace);
281 precomputed_builder.process_sel_range_8(trace);
282
283 // Manually populate destination tables for lookup interactions
284 auto contract_instance_data = create_test_contract_instance();
285
286 trace.set(
287 1,
288 { { // For deployment nullifier lookup
289 { C::nullifier_check_sel, 1 },
290 { C::nullifier_check_exists, 1 },
291 { C::nullifier_check_nullifier, contract_address },
292 { C::nullifier_check_root, nullifier_tree_root },
293 { C::nullifier_check_address, deployer_protocol_contract_address },
294 { C::nullifier_check_should_silo, 1 },
295 // For address derivation lookup
296 { C::address_derivation_sel, 1 },
297 { C::address_derivation_address, contract_address },
298 { C::address_derivation_salt, contract_instance_data.salt },
299 { C::address_derivation_deployer_addr, contract_instance_data.deployer_addr },
300 { C::address_derivation_class_id, contract_instance_data.original_class_id },
301 { C::address_derivation_init_hash, contract_instance_data.initialisation_hash },
302 { C::address_derivation_nullifier_key_x, contract_instance_data.public_keys.nullifier_key.x },
303 { C::address_derivation_nullifier_key_y, contract_instance_data.public_keys.nullifier_key.y },
304 { C::address_derivation_incoming_viewing_key_x, contract_instance_data.public_keys.incoming_viewing_key.x },
305 { C::address_derivation_incoming_viewing_key_y, contract_instance_data.public_keys.incoming_viewing_key.y },
306 { C::address_derivation_outgoing_viewing_key_x, contract_instance_data.public_keys.outgoing_viewing_key.x },
307 { C::address_derivation_outgoing_viewing_key_y, contract_instance_data.public_keys.outgoing_viewing_key.y },
308 { C::address_derivation_tagging_key_x, contract_instance_data.public_keys.tagging_key.x },
309 { C::address_derivation_tagging_key_y, contract_instance_data.public_keys.tagging_key.y },
310 // For update check lookup
311 { C::update_check_sel, 1 },
312 { C::update_check_address, contract_address },
313 { C::update_check_current_class_id, contract_instance_data.current_class_id },
314 { C::update_check_original_class_id, contract_instance_data.original_class_id },
315 { C::update_check_public_data_tree_root, public_data_tree_root },
316 { C::update_check_timestamp, timestamp },
317 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
318
319 check_relation<contract_instance_retrieval>(trace);
320
321 // Test lookup interactions
322 check_interaction<ContractInstanceRetrievalTraceBuilder,
323 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
324 check_interaction<ContractInstanceRetrievalTraceBuilder,
325 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
326 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
327 trace);
328}
329
330TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenNonExistentInstance)
331{
332 // Test constants
333 const auto contract_address = FF(0x999999999ULL);
334 const auto timestamp = 99999;
335 const auto nullifier_tree_root = FF(0xffffff);
336 const auto public_data_tree_root = FF(0xeeeeee);
337 const auto deployment_nullifier = FF(0x8888);
338 const auto deployer_protocol_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
339
340 // Use real tracegen to generate a valid trace for non-existent instance
341 EventEmitter<ContractInstanceRetrievalEvent> emitter;
342
343 ContractInstanceRetrievalEvent event{ .address = contract_address,
344 .contract_instance = {}, // no instance, DNE
345 .nullifier_tree_root = nullifier_tree_root,
346 .public_data_tree_root = public_data_tree_root,
347 .deployment_nullifier = deployment_nullifier,
348 .nullifier_exists = false, // Non-existent
349 .deployer_protocol_contract_address = deployer_protocol_contract_address,
350 .error = false };
351
352 emitter.emit(std::move(event));
353 auto events = emitter.dump_events();
354
355 TestTraceContainer trace;
356 ContractInstanceRetrievalTraceBuilder builder;
357 builder.process(events, trace);
358
359 // Add precomputed table entries
360 PrecomputedTraceBuilder precomputed_builder;
361 precomputed_builder.process_misc(trace, trace.get_num_rows());
362 precomputed_builder.process_get_contract_instance_table(trace);
363 precomputed_builder.process_sel_range_8(trace);
364
365 trace.set(1,
366 { { // For deployment nullifier read lookup
367 { C::nullifier_check_sel, 1 },
368 { C::nullifier_check_exists, 0 }, // Non-existent
369 { C::nullifier_check_nullifier, contract_address },
370 { C::nullifier_check_root, nullifier_tree_root },
371 { C::nullifier_check_address, deployer_protocol_contract_address },
372 { C::nullifier_check_should_silo, 1 },
373 // For address derivation lookup
374 { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist
375 { C::address_derivation_address, contract_address },
376 { C::address_derivation_salt, 0 }, // zero since nullifier doesn't exist
377 { C::address_derivation_deployer_addr, 0 }, // zero since nullifier doesn't exist
378 { C::address_derivation_class_id, 0 }, // zero since nullifier doesn't exist
379 { C::address_derivation_init_hash, 0 }, // zero since nullifier doesn't exist
380 { C::address_derivation_nullifier_key_x, 0 },
381 { C::address_derivation_nullifier_key_y, 0 },
382 { C::address_derivation_incoming_viewing_key_x, 0 },
383 { C::address_derivation_incoming_viewing_key_y, 0 },
384 { C::address_derivation_outgoing_viewing_key_x, 0 },
385 { C::address_derivation_outgoing_viewing_key_y, 0 },
386 { C::address_derivation_tagging_key_x, 0 },
387 { C::address_derivation_tagging_key_y, 0 },
388 // For update check lookup (only populated when nullifier exists)
389 { C::update_check_sel, 0 }, // Not selected since nullifier doesn't exist
390 { C::update_check_address, contract_address },
391 { C::update_check_current_class_id, 0 },
392 { C::update_check_original_class_id, 0 },
393 { C::update_check_public_data_tree_root, public_data_tree_root },
394 { C::update_check_timestamp, timestamp },
395 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
396
397 check_relation<contract_instance_retrieval>(trace);
398
399 // Test lookup interactions
400 check_interaction<ContractInstanceRetrievalTraceBuilder,
401 lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
402 check_interaction<ContractInstanceRetrievalTraceBuilder,
403 lookup_contract_instance_retrieval_address_derivation_settings>(trace);
404 check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
405 trace);
406}
407
408TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenMultipleInstances)
409{
410 // Test constants
411 const auto num_instances = 3;
412 const auto base_address = 0x1000;
413 const auto base_timestamp = 1000;
414 const auto base_nullifier_tree_root = 0x2000;
415 const auto base_public_data_tree_root = 0x3000;
416 const auto base_salt = 100;
417 const auto deployer_protocol_contract_address = FF(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS);
418
419 // Use real tracegen to generate multiple instances
420 EventEmitter<ContractInstanceRetrievalEvent> emitter;
421
422 for (uint32_t i = 0; i < num_instances; i++) {
423 auto contract_instance = create_test_contract_instance(base_salt + i);
424
425 ContractInstanceRetrievalEvent event = { .address = FF(base_address + i),
426 .contract_instance = contract_instance,
427 .nullifier_tree_root = FF(base_nullifier_tree_root + i),
428 .public_data_tree_root = FF(base_public_data_tree_root + i),
429 .deployment_nullifier = FF(base_address + i),
430 .nullifier_exists = true,
431 .deployer_protocol_contract_address =
432 deployer_protocol_contract_address,
433 .error = false };
434
435 emitter.emit(std::move(event));
436 }
437
438 auto events = emitter.dump_events();
439
440 TestTraceContainer trace;
441 ContractInstanceRetrievalTraceBuilder builder;
442 builder.process(events, trace);
443
444 // Add precomputed table entries
445 PrecomputedTraceBuilder precomputed_builder;
446 precomputed_builder.process_misc(trace, trace.get_num_rows());
447 precomputed_builder.process_get_contract_instance_table(trace);
448 precomputed_builder.process_sel_range_8(trace);
449
450 // Manually populate destination tables for lookup interactions
451 for (uint32_t i = 0; i < num_instances; i++) {
452 auto contract_instance_data = create_test_contract_instance(base_salt + i);
453 uint32_t row = i + 1; // Skip row 0 (skippable gadget)
454
455 trace.set(
456 row, // For deployment nullifier read lookup
457 { { { C::nullifier_check_sel, 1 },
458 { C::nullifier_check_exists, true },
459 { C::nullifier_check_nullifier, FF(base_address + i) },
460 { C::nullifier_check_root, FF(base_nullifier_tree_root + i) },
461 { C::nullifier_check_address, deployer_protocol_contract_address },
462 { C::nullifier_check_should_silo, 1 },
463 // For address derivation lookup (only when nullifier exists)
464 { C::address_derivation_sel, 1 },
465 { C::address_derivation_address, FF(base_address + i) },
466 { C::address_derivation_salt, contract_instance_data.salt },
467 { C::address_derivation_deployer_addr, contract_instance_data.deployer_addr },
468 { C::address_derivation_class_id, contract_instance_data.original_class_id },
469 { C::address_derivation_init_hash, contract_instance_data.initialisation_hash },
470 { C::address_derivation_nullifier_key_x, contract_instance_data.public_keys.nullifier_key.x },
471 { C::address_derivation_nullifier_key_y, contract_instance_data.public_keys.nullifier_key.y },
472 { C::address_derivation_incoming_viewing_key_x,
473 contract_instance_data.public_keys.incoming_viewing_key.x },
474 { C::address_derivation_incoming_viewing_key_y,
475 contract_instance_data.public_keys.incoming_viewing_key.y },
476 { C::address_derivation_outgoing_viewing_key_x,
477 contract_instance_data.public_keys.outgoing_viewing_key.x },
478 { C::address_derivation_outgoing_viewing_key_y,
479 contract_instance_data.public_keys.outgoing_viewing_key.y },
480 { C::address_derivation_tagging_key_x, contract_instance_data.public_keys.tagging_key.x },
481 { C::address_derivation_tagging_key_y, contract_instance_data.public_keys.tagging_key.y },
482 // For update check lookup (only when nullifier exists)
483 { C::update_check_sel, 1 },
484 { C::update_check_address, FF(base_address + i) },
485 { C::update_check_current_class_id, contract_instance_data.current_class_id },
486 { C::update_check_original_class_id, contract_instance_data.original_class_id },
487 { C::update_check_public_data_tree_root, FF(base_public_data_tree_root + i) },
488 { C::update_check_timestamp, base_timestamp + i },
489 { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
490 }
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
503} // namespace
504} // namespace bb::avm2::constraining
aztec_constants.hpp
AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX
#define AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX
Definition aztec_constants.hpp:105
CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS
#define CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS
Definition aztec_constants.hpp:21
aztec_types.hpp
check_relation.hpp
bb::avm2::contract_instance_retrieval
Definition contract_instance_retrieval.hpp:33
bb::avm2::tracegen::TraceContainer::set
void set(Column col, uint32_t row, const FF &value)
Definition trace_container.cpp:36
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:59
exists
bool exists
Definition nullifier_tree_check.test.cpp:73
contract_address
AztecAddress contract_address
Definition written_public_data_slots_tree_check.test.cpp:96
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::FF
AvmFlavorSettings::FF FF
Definition poseidon2.test.cpp:38
bb::avm2::constraining::TEST
TEST(TxExecutionConstrainingTest, WriteTreeValue)
Definition tx.test.cpp:508
bb::avm2::testing::empty_trace
TestTraceContainer empty_trace()
Definition fixtures.cpp:153
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:89
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:41
bb::FF
typename Flavor::FF FF
Definition protogalaxy.bench.cpp:16
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:20
original_class_id
FF original_class_id
Definition update_check.test.cpp:84
current_class_id
FF current_class_id
Definition update_check.test.cpp:85
test_trace_container.hpp