contract_instance_retrieval.test.cpp

Go to the documentation of this file.

#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <cstdint>
#include <memory>
#include <vector>
 
#include "barretenberg/aztec/aztec_constants.hpp"
#include "barretenberg/vm2/common/aztec_types.hpp"
#include "barretenberg/vm2/common/field.hpp"
#include "barretenberg/vm2/constraining/flavor_settings.hpp"
#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
#include "barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp"
#include "barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp"
#include "barretenberg/vm2/simulation/events/contract_instance_retrieval_event.hpp"
#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
#include "barretenberg/vm2/testing/fixtures.hpp"
#include "barretenberg/vm2/testing/macros.hpp"
#include "barretenberg/vm2/testing/public_inputs_builder.hpp"
#include "barretenberg/vm2/tracegen/contract_instance_retrieval_trace.hpp"
#include "barretenberg/vm2/tracegen/precomputed_trace.hpp"
#include "barretenberg/vm2/tracegen/public_inputs_trace.hpp"
#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
 
namespace bb::avm2::constraining {
namespace {
 
using simulation::ContractInstanceRetrievalEvent;
using simulation::EventEmitter;
using testing::PublicInputsBuilder;
using tracegen::ContractInstanceRetrievalTraceBuilder;
using tracegen::PrecomputedTraceBuilder;
using tracegen::PublicInputsTraceBuilder;
using tracegen::TestTraceContainer;
using FF = AvmFlavorSettings::FF;
using C = Column;
using contract_instance_retrieval = bb::avm2::contract_instance_retrieval<FF>;
 
// Helper to create a test contract instance
ContractInstance create_test_contract_instance(uint32_t salt_value = 123)
{
    return ContractInstance{
        .salt = FF(salt_value),
        .deployer = FF(0x123456789ULL),
        .current_contract_class_id = FF(0xdeadbeefULL),
        .original_contract_class_id = FF(0xcafebabeULL),
        .initialization_hash = FF(0x11111111ULL),
        .immutables_hash = FF(0x22222222ULL),
        .public_keys =
            PublicKeys{
                .nullifier_key_hash = FF(0x100),
                .incoming_viewing_key = { FF(0x200), FF(0x201) },
                .outgoing_viewing_key_hash = FF(0x300),
                .tagging_key_hash = FF(0x400),
                .message_signing_key_hash = FF(0x500),
                .fallback_key_hash = FF(0x600),
            },
    };
}
 
TEST(ContractInstanceRetrievalConstrainingTest, EmptyRow)
{
    check_relation<contract_instance_retrieval>(testing::empty_trace());
}
 
TEST(ContractInstanceRetrievalConstrainingTest, CompleteValidTrace)
{
    // Test constants
    const auto contract_address = FF(0x1234567890abcdefULL);
    const auto nullifier_tree_root = FF(0xaabbccdd);
    const auto public_data_tree_root = FF(0xeeff1122);
    const auto exists = true;
    const auto salt = FF(0x555);
    const auto deployer_addr = FF(0x123456789ULL);
    const auto current_class_id = FF(0xdeadbeefULL);
    const auto original_class_id = FF(0xcafebabeULL);
    const auto init_hash = FF(0x11111111ULL);
    const auto immutables_hash = FF(0x22222222ULL);
    const auto nullifier_key_hash = FF(0x100);
    const auto incoming_viewing_key_x = FF(0x200);
    const auto incoming_viewing_key_y = FF(0x201);
    const auto outgoing_viewing_key_hash = FF(0x300);
    const auto tagging_key_hash = FF(0x400);
    const auto message_signing_key_hash = FF(0x500);
    const auto fallback_key_hash = FF(0x600);
 
    // Test complete valid trace with all constraints
    TestTraceContainer trace({
        { { C::precomputed_first_row, 1 } },
        { { C::contract_instance_retrieval_sel, 1 },
          { C::contract_instance_retrieval_address, contract_address },
          { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
          { C::contract_instance_retrieval_salt, salt },
          { C::contract_instance_retrieval_deployer_addr, deployer_addr },
          { C::contract_instance_retrieval_current_class_id, current_class_id },
          { C::contract_instance_retrieval_original_class_id, original_class_id },
          { C::contract_instance_retrieval_init_hash, init_hash },
          { C::contract_instance_retrieval_immutables_hash, immutables_hash },
          { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
          { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
          { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
          { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
          { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
          { C::contract_instance_retrieval_nullifier_key_hash, nullifier_key_hash },
          { C::contract_instance_retrieval_incoming_viewing_key_x, incoming_viewing_key_x },
          { C::contract_instance_retrieval_incoming_viewing_key_y, incoming_viewing_key_y },
          { C::contract_instance_retrieval_outgoing_viewing_key_hash, outgoing_viewing_key_hash },
          { C::contract_instance_retrieval_tagging_key_hash, tagging_key_hash },
          { C::contract_instance_retrieval_message_signing_key_hash, message_signing_key_hash },
          { C::contract_instance_retrieval_fallback_key_hash, fallback_key_hash },
          { C::contract_instance_retrieval_deployer_protocol_contract_address,
            CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
          // Protocol Contract conditionals
          { C::contract_instance_retrieval_address_sub_one, contract_address - 1 },
          { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
          { C::contract_instance_retrieval_derived_address, contract_address },
          { C::contract_instance_retrieval_is_protocol_contract, 0 },
          { C::contract_instance_retrieval_should_check_nullifier, 1 },
          { C::contract_instance_retrieval_should_check_for_update, 1 } },
    });
 
    check_relation<contract_instance_retrieval>(trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, MultipleInstancesTrace)
{
    // Test constants
    const auto num_instances = 3;
    const auto base_address = 0x1000;
    const auto base_nullifier_tree_root = 0x2000;
    const auto base_public_data_tree_root = 0x3000;
    const auto base_salt = 100;
 
    // Test multiple contract instances in sequence
    std::vector<std::vector<std::pair<C, FF>>> trace_data;
 
    // First row
    trace_data.push_back({ { C::precomputed_first_row, 1 } });
 
    // Create multiple instance rows
    for (uint32_t i = 0; i < num_instances; i++) {
        auto contract_instance = create_test_contract_instance(base_salt + i);
 
        trace_data.push_back({
            { C::contract_instance_retrieval_sel, 1 },
            { C::contract_instance_retrieval_address, FF(base_address + i) },
            { C::contract_instance_retrieval_exists, 1 },
            { C::contract_instance_retrieval_salt, contract_instance.salt },
            { C::contract_instance_retrieval_deployer_addr, contract_instance.deployer },
            { C::contract_instance_retrieval_current_class_id, contract_instance.current_contract_class_id },
            { C::contract_instance_retrieval_original_class_id, contract_instance.original_contract_class_id },
            { C::contract_instance_retrieval_init_hash, contract_instance.initialization_hash },
            { C::contract_instance_retrieval_immutables_hash, contract_instance.immutables_hash },
            { C::contract_instance_retrieval_public_data_tree_root, FF(base_public_data_tree_root + i) },
            { C::contract_instance_retrieval_nullifier_tree_root, FF(base_nullifier_tree_root + i) },
            { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
            { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
            { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
            { C::contract_instance_retrieval_nullifier_key_hash, contract_instance.public_keys.nullifier_key_hash },
            { C::contract_instance_retrieval_incoming_viewing_key_x,
              contract_instance.public_keys.incoming_viewing_key.x },
            { C::contract_instance_retrieval_incoming_viewing_key_y,
              contract_instance.public_keys.incoming_viewing_key.y },
            { C::contract_instance_retrieval_outgoing_viewing_key_hash,
              contract_instance.public_keys.outgoing_viewing_key_hash },
            { C::contract_instance_retrieval_tagging_key_hash, contract_instance.public_keys.tagging_key_hash },
            { C::contract_instance_retrieval_message_signing_key_hash,
              contract_instance.public_keys.message_signing_key_hash },
            { C::contract_instance_retrieval_fallback_key_hash, contract_instance.public_keys.fallback_key_hash },
            { C::contract_instance_retrieval_deployer_protocol_contract_address,
              CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
            // Protocol Contract conditionals
            { C::contract_instance_retrieval_address_sub_one, (base_address + i) - 1 },
            { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
            { C::contract_instance_retrieval_derived_address, base_address + i },
            { C::contract_instance_retrieval_is_protocol_contract, 0 },
            { C::contract_instance_retrieval_should_check_nullifier, 1 },
            { C::contract_instance_retrieval_should_check_for_update, 1 },
        });
    }
 
    TestTraceContainer trace(trace_data);
    check_relation<contract_instance_retrieval>(trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, NonExistentInstanceTrace)
{
    // Test constants
    const auto contract_address = FF(0x99999999);
    const auto nullifier_tree_root = FF(0xffffff);
    const auto public_data_tree_root = FF(0xeeeeee);
    const auto exists = false;
 
    // Test trace for non-existent contract instance
    TestTraceContainer trace({
        { { C::precomputed_first_row, 1 } },
        { { C::contract_instance_retrieval_sel, 1 },
          { C::contract_instance_retrieval_address, contract_address },
          { C::contract_instance_retrieval_exists, exists ? 1 : 0 },
          { C::contract_instance_retrieval_salt, 0 },
          { C::contract_instance_retrieval_deployer_addr, 0 },
          { C::contract_instance_retrieval_current_class_id, 0 },
          { C::contract_instance_retrieval_original_class_id, 0 },
          { C::contract_instance_retrieval_init_hash, 0 },
          { C::contract_instance_retrieval_immutables_hash, 0 },
          { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
          { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
          { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
          { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
          { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
          { C::contract_instance_retrieval_deployer_protocol_contract_address,
            CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
          // Protocol Contract conditionals
          { C::contract_instance_retrieval_address_sub_one, contract_address - 1 },
          { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
          { C::contract_instance_retrieval_derived_address, contract_address },
          { C::contract_instance_retrieval_is_protocol_contract, 0 },
          { C::contract_instance_retrieval_should_check_nullifier, 1 },
          { C::contract_instance_retrieval_should_check_for_update, 0 /*since exists = false*/ } },
    });
 
    check_relation<contract_instance_retrieval>(trace);
 
    // mutate instance members to be nonzero and confirm that relation fails
    // mutate deployer_addr
    trace.set(C::contract_instance_retrieval_deployer_addr, 1, 1);
    EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
                              contract_instance_retrieval::get_subrelation_label(
                                  contract_instance_retrieval::SR_INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE));
    // reset
    trace.set(C::contract_instance_retrieval_deployer_addr, 1, 0);
    // mutate current_class_id
    trace.set(C::contract_instance_retrieval_current_class_id, 1, 1);
    EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
                              contract_instance_retrieval::get_subrelation_label(
                                  contract_instance_retrieval::SR_INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE));
    // reset
    trace.set(C::contract_instance_retrieval_current_class_id, 1, 0);
    // mutate original_class_id
    trace.set(C::contract_instance_retrieval_original_class_id, 1, 1);
    EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
                              contract_instance_retrieval::get_subrelation_label(
                                  contract_instance_retrieval::SR_INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE));
    // reset
    trace.set(C::contract_instance_retrieval_original_class_id, 1, 0);
    // mutate init_hash
    trace.set(C::contract_instance_retrieval_init_hash, 1, 1);
    EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
                              contract_instance_retrieval::get_subrelation_label(
                                  contract_instance_retrieval::SR_INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE));
    // reset
    trace.set(C::contract_instance_retrieval_init_hash, 1, 0);
    // mutate immutables_hash
    trace.set(C::contract_instance_retrieval_immutables_hash, 1, 1);
    EXPECT_THROW_WITH_MESSAGE(check_relation<contract_instance_retrieval>(trace),
                              contract_instance_retrieval::get_subrelation_label(
                                  contract_instance_retrieval::SR_INSTANCE_MEMBER_IMMUTABLES_HASH_IS_ZERO_IF_DNE));
    // reset
    trace.set(C::contract_instance_retrieval_immutables_hash, 1, 0);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, MaximumFieldValuesTrace)
{
    // Test constants
    const auto max_field = FF(-1); // Maximum field value
 
    // Test trace with maximum field values
    TestTraceContainer trace({
        { { C::precomputed_first_row, 1 } },
        { { C::contract_instance_retrieval_sel, 1 },
          { C::contract_instance_retrieval_address, max_field },
          { C::contract_instance_retrieval_exists, 1 },
          { C::contract_instance_retrieval_salt, max_field },
          { C::contract_instance_retrieval_deployer_addr, max_field },
          { C::contract_instance_retrieval_current_class_id, max_field },
          { C::contract_instance_retrieval_original_class_id, max_field },
          { C::contract_instance_retrieval_init_hash, max_field },
          { C::contract_instance_retrieval_immutables_hash, max_field },
          { C::contract_instance_retrieval_public_data_tree_root, max_field },
          { C::contract_instance_retrieval_nullifier_tree_root, max_field },
          { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT },
          { C::contract_instance_retrieval_nullifier_merkle_separator, DOM_SEP__NULLIFIER_MERKLE },
          { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
          { C::contract_instance_retrieval_nullifier_key_hash, max_field },
          { C::contract_instance_retrieval_incoming_viewing_key_x, max_field },
          { C::contract_instance_retrieval_incoming_viewing_key_y, max_field },
          { C::contract_instance_retrieval_outgoing_viewing_key_hash, max_field },
          { C::contract_instance_retrieval_tagging_key_hash, max_field },
          { C::contract_instance_retrieval_message_signing_key_hash, max_field },
          { C::contract_instance_retrieval_fallback_key_hash, max_field },
          { C::contract_instance_retrieval_deployer_protocol_contract_address,
            CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
          // Protocol Contract conditionals
          { C::contract_instance_retrieval_address_sub_one, max_field - 1 },
          { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
          { C::contract_instance_retrieval_derived_address, max_field },
          { C::contract_instance_retrieval_is_protocol_contract, 0 },
          { C::contract_instance_retrieval_should_check_nullifier, 1 },
          { C::contract_instance_retrieval_should_check_for_update, 1 } },
    });
 
    check_relation<contract_instance_retrieval>(trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, ProtocolContractInstanceExists)
{
    // Test constants
    const AztecAddress contract_address = FEE_JUICE_ADDRESS;
    const AztecAddress derived_address = FF(0xabcdef1234567890ULL);
    const auto nullifier_tree_root = FF(0xbadc0ffeeULL);
    const auto public_data_tree_root = FF(0xfacefeedUL);
    ProtocolContracts protocol_contracts = {};
    uint32_t protocol_contract_index = static_cast<uint32_t>(contract_address - 1);
    protocol_contracts.derived_addresses[protocol_contract_index] = derived_address;
 
    auto public_inputs = PublicInputsBuilder().set_protocol_contracts(protocol_contracts).build();
 
    // Test complete valid trace with all constraints
    TestTraceContainer trace({
        {
            { C::precomputed_first_row, 1 },
            // Field Greater-Than Trace for Protocol Contract Address Check
            { C::ff_gt_sel, 1 },
            { C::ff_gt_sel_gt, 1 },
            { C::ff_gt_a, MAX_PROTOCOL_CONTRACTS },
            { C::ff_gt_b, contract_address - FF(1) },
            { C::ff_gt_result, 1 },
        },
        {
            // Contract Retrieval Instance Trace
            { C::contract_instance_retrieval_sel, 1 },
            { C::contract_instance_retrieval_address, contract_address },
            { C::contract_instance_retrieval_exists, 1 },
            { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
            { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
            { C::contract_instance_retrieval_deployer_protocol_contract_address,
              CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
            // Protocol Contract conditionals
            { C::contract_instance_retrieval_derived_address_pi_index,
              AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX + protocol_contract_index },
            { C::contract_instance_retrieval_protocol_contract_derived_address_inv, derived_address.invert() },
            { C::contract_instance_retrieval_address_sub_one, contract_address - FF(1) },
            { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
            { C::contract_instance_retrieval_derived_address, derived_address },
            { C::contract_instance_retrieval_is_protocol_contract, 1 },
            { C::contract_instance_retrieval_should_check_nullifier, 0 },
            { C::contract_instance_retrieval_should_check_for_update, 0 },
        },
    });
 
    PublicInputsTraceBuilder public_inputs_builder;
    public_inputs_builder.process_public_inputs(trace, public_inputs);
    public_inputs_builder.process_public_inputs_aux_precomputed(trace);
 
    tracegen::PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
 
    check_relation<contract_instance_retrieval>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings,
                      lookup_contract_instance_retrieval_check_protocol_address_range_settings>(trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, ProtocolContractInstanceNotExists)
{
    // Test constants
    const AztecAddress contract_address = FEE_JUICE_ADDRESS;
    const AztecAddress derived_address = FF(0);
    const auto nullifier_tree_root = FF(0xbadc0ffeeULL);
    const auto public_data_tree_root = FF(0xfacefeedUL);
    uint32_t protocol_contract_index = static_cast<uint32_t>(contract_address - 1);
    // Default protocol contracts: empty
    auto public_inputs = PublicInputsBuilder().build();
 
    // Test complete valid trace with all constraints
    TestTraceContainer trace({
        {
            { C::precomputed_first_row, 1 },
            // Field Greater-Than Trace for Protocol Contract Address Check
            { C::ff_gt_sel, 1 },
            { C::ff_gt_sel_gt, 1 },
            { C::ff_gt_a, MAX_PROTOCOL_CONTRACTS },
            { C::ff_gt_b, contract_address - FF(1) },
            { C::ff_gt_result, 1 },
        },
        {
            // Contract Retrieval Instance Trace
            { C::contract_instance_retrieval_sel, 1 },
            { C::contract_instance_retrieval_address, contract_address },
            { C::contract_instance_retrieval_exists, 0 },
            { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root },
            { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root },
            { C::contract_instance_retrieval_deployer_protocol_contract_address,
              CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
            // Protocol Contract conditionals
            { C::contract_instance_retrieval_derived_address_pi_index,
              AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX + protocol_contract_index },
            { C::contract_instance_retrieval_protocol_contract_derived_address_inv, 0 },
            { C::contract_instance_retrieval_address_sub_one, contract_address - FF(1) },
            { C::contract_instance_retrieval_max_protocol_contracts, MAX_PROTOCOL_CONTRACTS },
            { C::contract_instance_retrieval_derived_address, derived_address },
            { C::contract_instance_retrieval_is_protocol_contract, 1 },
            { C::contract_instance_retrieval_should_check_nullifier, 0 },
            { C::contract_instance_retrieval_should_check_for_update, 0 },
        },
    });
 
    PublicInputsTraceBuilder public_inputs_builder;
    public_inputs_builder.process_public_inputs(trace, public_inputs);
    public_inputs_builder.process_public_inputs_aux_precomputed(trace);
 
    tracegen::PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
 
    check_relation<contract_instance_retrieval>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_settings,
                      lookup_contract_instance_retrieval_check_protocol_address_range_settings>(trace);
}
 
// Integration-style tests using tracegen components
TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenValidInstance)
{
    // Test constants
    const auto contract_address = FF(0x1234567890abcdefULL);
    const auto timestamp = 12345;
    const auto nullifier_tree_root = FF(0xaabbccdd);
    const auto public_data_tree_root = FF(0xeeff1122);
    const auto deployment_nullifier = FF(0x7777);
 
    // Use real tracegen to generate a valid trace
    EventEmitter<ContractInstanceRetrievalEvent> emitter;
    auto contract_instance = create_test_contract_instance();
 
    ContractInstanceRetrievalEvent event = { .address = contract_address,
                                             .contract_instance = contract_instance,
                                             .nullifier_tree_root = nullifier_tree_root,
                                             .public_data_tree_root = public_data_tree_root,
                                             .deployment_nullifier = deployment_nullifier,
                                             .exists = true,
                                             .is_protocol_contract = false };
 
    emitter.emit(std::move(event));
    auto events = emitter.dump_events();
 
    TestTraceContainer trace;
    ContractInstanceRetrievalTraceBuilder builder;
    builder.process(events, trace);
 
    // Add precomputed table entries
    PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
    precomputed_builder.process_get_contract_instance_table(trace);
    precomputed_builder.process_sel_range_8(trace);
 
    // Manually populate destination tables for lookup interactions
    auto contract_instance_data = create_test_contract_instance();
 
    trace.set(
        1,
        { { // For deployment nullifier lookup
            { C::indexed_tree_check_sel, 1 },
            { C::indexed_tree_check_exists, 1 },
            { C::indexed_tree_check_value, contract_address },
            { C::indexed_tree_check_root, nullifier_tree_root },
            { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
            { C::indexed_tree_check_sel_silo, 1 },
            { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
            { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
            { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
            // For address derivation lookup
            { C::address_derivation_sel, 1 },
            { C::address_derivation_address, contract_address },
            { C::address_derivation_salt, contract_instance_data.salt },
            { C::address_derivation_deployer_addr, contract_instance_data.deployer },
            { C::address_derivation_class_id, contract_instance_data.original_contract_class_id },
            { C::address_derivation_init_hash, contract_instance_data.initialization_hash },
            { C::address_derivation_immutables_hash, contract_instance_data.immutables_hash },
            { C::address_derivation_nullifier_key_hash, contract_instance_data.public_keys.nullifier_key_hash },
            { C::address_derivation_incoming_viewing_key_x, contract_instance_data.public_keys.incoming_viewing_key.x },
            { C::address_derivation_incoming_viewing_key_y, contract_instance_data.public_keys.incoming_viewing_key.y },
            { C::address_derivation_outgoing_viewing_key_hash,
              contract_instance_data.public_keys.outgoing_viewing_key_hash },
            { C::address_derivation_tagging_key_hash, contract_instance_data.public_keys.tagging_key_hash },
            { C::address_derivation_message_signing_key_hash,
              contract_instance_data.public_keys.message_signing_key_hash },
            { C::address_derivation_fallback_key_hash, contract_instance_data.public_keys.fallback_key_hash },
            // For update check lookup
            { C::update_check_sel, 1 },
            { C::update_check_address, contract_address },
            { C::update_check_current_class_id, contract_instance_data.current_contract_class_id },
            { C::update_check_original_class_id, contract_instance_data.original_contract_class_id },
            { C::update_check_public_data_tree_root, public_data_tree_root },
            { C::update_check_timestamp, timestamp },
            { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
 
    check_relation<contract_instance_retrieval>(trace);
 
    // Test lookup interactions
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_address_derivation_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
        trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenNonExistentInstance)
{
    // Test constants
    const auto contract_address = FF(0x999999999ULL);
    const auto timestamp = 99999;
    const auto nullifier_tree_root = FF(0xffffff);
    const auto public_data_tree_root = FF(0xeeeeee);
    const auto deployment_nullifier = FF(0x8888);
 
    // Use real tracegen to generate a valid trace for non-existent instance
    EventEmitter<ContractInstanceRetrievalEvent> emitter;
 
    ContractInstanceRetrievalEvent event{ .address = contract_address,
                                          .contract_instance = {}, // no instance, DNE
                                          .nullifier_tree_root = nullifier_tree_root,
                                          .public_data_tree_root = public_data_tree_root,
                                          .deployment_nullifier = deployment_nullifier,
                                          .exists = false, // Non-existent
                                          .is_protocol_contract = false };
 
    emitter.emit(std::move(event));
    auto events = emitter.dump_events();
 
    TestTraceContainer trace;
    ContractInstanceRetrievalTraceBuilder builder;
    builder.process(events, trace);
 
    // Add precomputed table entries
    PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
    precomputed_builder.process_get_contract_instance_table(trace);
    precomputed_builder.process_sel_range_8(trace);
 
    trace.set(1,
              { { // For deployment nullifier read lookup
                  { C::indexed_tree_check_sel, 1 },
                  { C::indexed_tree_check_exists, 0 }, // Non-existent
                  { C::indexed_tree_check_value, contract_address },
                  { C::indexed_tree_check_root, nullifier_tree_root },
                  { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
                  { C::indexed_tree_check_sel_silo, 1 },
                  { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
                  { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
                  { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
                  // For address derivation lookup
                  { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist
                  { C::address_derivation_address, contract_address },
                  { C::address_derivation_salt, 0 },            // zero since nullifier doesn't exist
                  { C::address_derivation_deployer_addr, 0 },   // zero since nullifier doesn't exist
                  { C::address_derivation_class_id, 0 },        // zero since nullifier doesn't exist
                  { C::address_derivation_init_hash, 0 },       // zero since nullifier doesn't exist
                  { C::address_derivation_immutables_hash, 0 }, // zero since nullifier doesn't exist
                  { C::address_derivation_nullifier_key_hash, 0 },
                  { C::address_derivation_incoming_viewing_key_x, 0 },
                  { C::address_derivation_incoming_viewing_key_y, 0 },
                  { C::address_derivation_outgoing_viewing_key_hash, 0 },
                  { C::address_derivation_tagging_key_hash, 0 },
                  { C::address_derivation_message_signing_key_hash, 0 },
                  { C::address_derivation_fallback_key_hash, 0 },
                  // For update check lookup (only populated when nullifier exists)
                  { C::update_check_sel, 0 }, // Not selected since nullifier doesn't exist
                  { C::update_check_address, contract_address },
                  { C::update_check_current_class_id, 0 },
                  { C::update_check_original_class_id, 0 },
                  { C::update_check_public_data_tree_root, public_data_tree_root },
                  { C::update_check_timestamp, timestamp },
                  { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
 
    check_relation<contract_instance_retrieval>(trace);
 
    // Test lookup interactions
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_address_derivation_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
        trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenAddressZero)
{
    // Test constants
    const auto contract_address = FF(0);
    const auto timestamp = 99999;
    const auto nullifier_tree_root = FF(0xffffff);
    const auto public_data_tree_root = FF(0xeeeeee);
    const auto deployment_nullifier = FF(0x8888);
 
    // Use real tracegen to generate a valid trace for non-existent instance
    EventEmitter<ContractInstanceRetrievalEvent> emitter;
 
    ContractInstanceRetrievalEvent event{
        .address = contract_address,
        .contract_instance = {}, // no instance, DNE
        .nullifier_tree_root = nullifier_tree_root,
        .public_data_tree_root = public_data_tree_root,
        .deployment_nullifier = deployment_nullifier,
        .exists = false,               // Non-existent
        .is_protocol_contract = false, // Not a protocol contract, since MAX_PROTOCOL_CONTRACTS < (0 - 1)
    };
 
    emitter.emit(std::move(event));
    auto events = emitter.dump_events();
 
    TestTraceContainer trace;
    ContractInstanceRetrievalTraceBuilder builder;
    builder.process(events, trace);
 
    // Add precomputed table entries
    PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
    precomputed_builder.process_get_contract_instance_table(trace);
    precomputed_builder.process_sel_range_8(trace);
 
    trace.set(1,
              { { // For deployment nullifier read lookup
                  { C::indexed_tree_check_sel, 1 },
                  { C::indexed_tree_check_exists, 0 }, // Non-existent
                  { C::indexed_tree_check_value, contract_address },
                  { C::indexed_tree_check_root, nullifier_tree_root },
                  { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
                  { C::indexed_tree_check_sel_silo, 1 },
                  { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
                  { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
                  { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
                  // For address derivation lookup
                  { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist
                  { C::address_derivation_address, contract_address },
                  { C::address_derivation_salt, 0 },            // zero since nullifier doesn't exist
                  { C::address_derivation_deployer_addr, 0 },   // zero since nullifier doesn't exist
                  { C::address_derivation_class_id, 0 },        // zero since nullifier doesn't exist
                  { C::address_derivation_init_hash, 0 },       // zero since nullifier doesn't exist
                  { C::address_derivation_immutables_hash, 0 }, // zero since nullifier doesn't exist
                  { C::address_derivation_nullifier_key_hash, 0 },
                  { C::address_derivation_incoming_viewing_key_x, 0 },
                  { C::address_derivation_incoming_viewing_key_y, 0 },
                  { C::address_derivation_outgoing_viewing_key_hash, 0 },
                  { C::address_derivation_tagging_key_hash, 0 },
                  { C::address_derivation_message_signing_key_hash, 0 },
                  { C::address_derivation_fallback_key_hash, 0 },
                  // For update check lookup (only populated when nullifier exists)
                  { C::update_check_sel, 0 }, // Not selected since nullifier doesn't exist
                  { C::update_check_address, contract_address },
                  { C::update_check_current_class_id, 0 },
                  { C::update_check_original_class_id, 0 },
                  { C::update_check_public_data_tree_root, public_data_tree_root },
                  { C::update_check_timestamp, timestamp },
                  { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
 
    check_relation<contract_instance_retrieval>(trace);
 
    // Test lookup interactions
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_address_derivation_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
        trace);
}
 
TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenMultipleInstances)
{
    // Test constants
    const auto num_instances = 3;
    const auto base_address = 0x1000;
    const auto base_timestamp = 1000;
    const auto base_nullifier_tree_root = 0x2000;
    const auto base_public_data_tree_root = 0x3000;
    const auto base_salt = 100;
 
    // Use real tracegen to generate multiple instances
    EventEmitter<ContractInstanceRetrievalEvent> emitter;
 
    for (uint32_t i = 0; i < num_instances; i++) {
        auto contract_instance = create_test_contract_instance(base_salt + i);
 
        ContractInstanceRetrievalEvent event = { .address = FF(base_address + i),
                                                 .contract_instance = contract_instance,
                                                 .nullifier_tree_root = FF(base_nullifier_tree_root + i),
                                                 .public_data_tree_root = FF(base_public_data_tree_root + i),
                                                 .deployment_nullifier = FF(base_address + i),
                                                 .exists = true,
                                                 .is_protocol_contract = false };
 
        emitter.emit(std::move(event));
    }
 
    auto events = emitter.dump_events();
 
    TestTraceContainer trace;
    ContractInstanceRetrievalTraceBuilder builder;
    builder.process(events, trace);
 
    // Add precomputed table entries
    PrecomputedTraceBuilder precomputed_builder;
    precomputed_builder.process_misc(trace, trace.get_num_rows());
    precomputed_builder.process_get_contract_instance_table(trace);
    precomputed_builder.process_sel_range_8(trace);
 
    // Manually populate destination tables for lookup interactions
    for (uint32_t i = 0; i < num_instances; i++) {
        auto contract_instance_data = create_test_contract_instance(base_salt + i);
        uint32_t row = i + 1; // Skip row 0 (skippable gadget)
 
        trace.set(
            row, // For deployment nullifier read lookup
            { { { C::indexed_tree_check_sel, 1 },
                { C::indexed_tree_check_exists, true },
                { C::indexed_tree_check_value, FF(base_address + i) },
                { C::indexed_tree_check_root, FF(base_nullifier_tree_root + i) },
                { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS },
                { C::indexed_tree_check_sel_silo, 1 },
                { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT },
                { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER },
                { C::indexed_tree_check_merkle_hash_separator, DOM_SEP__NULLIFIER_MERKLE },
                // For address derivation lookup (only when nullifier exists)
                { C::address_derivation_sel, 1 },
                { C::address_derivation_address, FF(base_address + i) },
                { C::address_derivation_salt, contract_instance_data.salt },
                { C::address_derivation_deployer_addr, contract_instance_data.deployer },
                { C::address_derivation_class_id, contract_instance_data.original_contract_class_id },
                { C::address_derivation_init_hash, contract_instance_data.initialization_hash },
                { C::address_derivation_immutables_hash, contract_instance_data.immutables_hash },
                { C::address_derivation_nullifier_key_hash, contract_instance_data.public_keys.nullifier_key_hash },
                { C::address_derivation_incoming_viewing_key_x,
                  contract_instance_data.public_keys.incoming_viewing_key.x },
                { C::address_derivation_incoming_viewing_key_y,
                  contract_instance_data.public_keys.incoming_viewing_key.y },
                { C::address_derivation_outgoing_viewing_key_hash,
                  contract_instance_data.public_keys.outgoing_viewing_key_hash },
                { C::address_derivation_tagging_key_hash, contract_instance_data.public_keys.tagging_key_hash },
                { C::address_derivation_message_signing_key_hash,
                  contract_instance_data.public_keys.message_signing_key_hash },
                { C::address_derivation_fallback_key_hash, contract_instance_data.public_keys.fallback_key_hash },
                // For update check lookup (only when nullifier exists)
                { C::update_check_sel, 1 },
                { C::update_check_address, FF(base_address + i) },
                { C::update_check_current_class_id, contract_instance_data.current_contract_class_id },
                { C::update_check_original_class_id, contract_instance_data.original_contract_class_id },
                { C::update_check_public_data_tree_root, FF(base_public_data_tree_root + i) },
                { C::update_check_timestamp, base_timestamp + i },
                { C::update_check_timestamp_pi_offset, AVM_PUBLIC_INPUTS_GLOBAL_VARIABLES_TIMESTAMP_ROW_IDX } } });
    }
 
    check_relation<contract_instance_retrieval>(trace);
 
    // Test lookup interactions
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_deployment_nullifier_read_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder,
                      lookup_contract_instance_retrieval_address_derivation_settings>(trace);
    check_interaction<ContractInstanceRetrievalTraceBuilder, lookup_contract_instance_retrieval_update_check_settings>(
        trace);
}
 
} // namespace
} // namespace bb::avm2::constraining