hinting_dbs.cpp

Go to the documentation of this file.

#include "barretenberg/vm2/simulation/lib/hinting_dbs.hpp"
 
#include <cstdint>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "barretenberg/common/log.hpp"
#include "barretenberg/vm2/common/avm_io.hpp"
#include "barretenberg/vm2/common/aztec_types.hpp"
#include "barretenberg/vm2/simulation/interfaces/db.hpp"
#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
 
namespace bb::avm2::simulation {
 
// HintingContractsDB starts.
std::optional<ContractInstance> HintingContractsDB::get_contract_instance(const AztecAddress& address) const
{
    std::optional<ContractInstance> instance = db.get_contract_instance(address);
    // If we don't find the instance hint, this is not a catastrophic failure. The inner db should handle it, and
    // here we simply don't store any hint:
    if (instance.has_value()) {
        GetContractInstanceKey key = { checkpoint_action_counter, address };
        contract_hints.contract_instances[key] = ContractInstanceHint{
            .hint_key = checkpoint_action_counter,
            .address = address,
            .salt = instance->salt,
            .deployer = instance->deployer,
            .current_contract_class_id = instance->current_contract_class_id,
            .original_contract_class_id = instance->original_contract_class_id,
            .initialization_hash = instance->initialization_hash,
            .immutables_hash = instance->immutables_hash,
            .public_keys = PublicKeysHint{ .npk_m_hash = instance->public_keys.nullifier_key_hash,
                                           .ivpk_m = instance->public_keys.incoming_viewing_key,
                                           .ovpk_m_hash = instance->public_keys.outgoing_viewing_key_hash,
                                           .tpk_m_hash = instance->public_keys.tagging_key_hash,
                                           .mspk_m_hash = instance->public_keys.message_signing_key_hash,
                                           .fbpk_m_hash = instance->public_keys.fallback_key_hash }
 
        };
    }
 
    return instance;
}
 
std::optional<ContractClass> HintingContractsDB::get_contract_class(const ContractClassId& class_id) const
{
    std::optional<ContractClass> klass = db.get_contract_class(class_id);
    // If we don't find the instance hint, this is not a catastrophic failure. The inner db should handle it, and
    // here we simply don't store any hint:
    if (klass.has_value()) {
        GetContractClassKey key = { checkpoint_action_counter, class_id };
        contract_hints.contract_classes[key] = ContractClassHint{
            .hint_key = checkpoint_action_counter,
            .class_id = class_id,
            .artifact_hash = klass->artifact_hash,
            .private_functions_root = klass->private_functions_root,
            // TODO(fcarreiro): find out why moving things here breaks things
            .packed_bytecode = klass->packed_bytecode,
        };
    }
 
    return klass;
}
 
std::optional<FF> HintingContractsDB::get_bytecode_commitment(const ContractClassId& class_id) const
{
    std::optional<FF> commitment = db.get_bytecode_commitment(class_id);
    if (commitment.has_value()) {
        GetBytecodeCommitmentKey key = { checkpoint_action_counter, class_id };
        contract_hints.bytecode_commitments[key] = BytecodeCommitmentHint{ .hint_key = checkpoint_action_counter,
                                                                           .class_id = class_id,
                                                                           .commitment = commitment.value() };
    }
 
    return commitment;
}
 
std::optional<std::string> HintingContractsDB::get_debug_function_name(const AztecAddress& address,
                                                                       const FunctionSelector& selector) const
{
    std::optional<std::string> name = db.get_debug_function_name(address, selector);
    if (name.has_value()) {
        GetDebugFunctionNameKey key = { address, selector };
        contract_hints.debug_function_names[key] =
            DebugFunctionNameHint{ .address = address, .selector = selector, .name = name.value() };
    }
 
    return name;
}
 
void HintingContractsDB::add_contracts(const ContractDeploymentData& contract_deployment_data)
{
    // Adding contracts does not require any hints
    db.add_contracts(contract_deployment_data);
}
 
void HintingContractsDB::create_checkpoint()
{
    uint32_t old_checkpoint_id = get_checkpoint_id();
    // Update underlying db:
    db.create_checkpoint();
    // Update this db:
    checkpoint_stack.push(next_checkpoint_id++);
    // Store hint:
    contract_hints.create_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = get_checkpoint_id(),
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
void HintingContractsDB::commit_checkpoint()
{
    uint32_t old_checkpoint_id = get_checkpoint_id();
    // Update underlying db:
    db.commit_checkpoint();
    // Update this db:
    checkpoint_stack.pop();
    // Store hint:
    contract_hints.commit_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = get_checkpoint_id(),
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
void HintingContractsDB::revert_checkpoint()
{
    uint32_t old_checkpoint_id = get_checkpoint_id();
    // Update underlying db:
    db.revert_checkpoint();
    // Update this db:
    checkpoint_stack.pop();
    // Store hint:
    contract_hints.revert_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = get_checkpoint_id(),
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
uint32_t HintingContractsDB::get_checkpoint_id() const
{
    return checkpoint_stack.top();
}
 
void HintingContractsDB::dump_hints(ExecutionHints& hints)
{
    std::ranges::transform(contract_hints.contract_instances,
                           std::back_inserter(hints.contract_instances),
                           [](const auto& mapped_contract_instance) { return mapped_contract_instance.second; });
 
    std::ranges::transform(contract_hints.contract_classes,
                           std::back_inserter(hints.contract_classes),
                           [](const auto& mapped_contract_class) { return mapped_contract_class.second; });
 
    std::ranges::transform(contract_hints.bytecode_commitments,
                           std::back_inserter(hints.bytecode_commitments),
                           [](const auto& mapped_bytecode_commitment) { return mapped_bytecode_commitment.second; });
 
    std::ranges::transform(contract_hints.debug_function_names,
                           std::back_inserter(hints.debug_function_names),
                           [](const auto& mapped_debug_function_name) { return mapped_debug_function_name.second; });
 
    std::ranges::transform(
        contract_hints.create_checkpoint_hints,
        std::back_inserter(hints.contract_db_create_checkpoint_hints),
        [](const auto& mapped_create_checkpoint_hint) { return mapped_create_checkpoint_hint.second; });
 
    std::ranges::transform(
        contract_hints.commit_checkpoint_hints,
        std::back_inserter(hints.contract_db_commit_checkpoint_hints),
        [](const auto& mapped_commit_checkpoint_hint) { return mapped_commit_checkpoint_hint.second; });
 
    std::ranges::transform(
        contract_hints.revert_checkpoint_hints,
        std::back_inserter(hints.contract_db_revert_checkpoint_hints),
        [](const auto& mapped_revert_checkpoint_hint) { return mapped_revert_checkpoint_hint.second; });
}
 
// Hinting MerkleDB starts.
AppendOnlyTreeSnapshot HintingRawDB::get_tree_info(world_state::MerkleTreeId tree_id) const
{
    auto roots = db.get_tree_roots();
    return get_tree_info_helper(tree_id, roots);
}
 
SiblingPath HintingRawDB::get_sibling_path(world_state::MerkleTreeId tree_id, index_t leaf_index) const
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(tree_id);
    SiblingPath path = db.get_sibling_path(tree_id, leaf_index);
    GetSiblingPathKey key = { tree_info, tree_id, leaf_index };
    merkle_hints.get_sibling_path_hints[key] =
        GetSiblingPathHint{ .hint_key = tree_info, .tree_id = tree_id, .index = leaf_index, .path = path };
 
    return path;
}
 
GetLowIndexedLeafResponse HintingRawDB::get_low_indexed_leaf(world_state::MerkleTreeId tree_id, const FF& value) const
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(tree_id);
    GetLowIndexedLeafResponse resp = db.get_low_indexed_leaf(tree_id, value);
    GetPreviousValueIndexKey key = { tree_info, tree_id, value };
    merkle_hints.get_previous_value_index_hints[key] = GetPreviousValueIndexHint{
        .hint_key = tree_info,
        .tree_id = tree_id,
        .value = value,
        .index = resp.index,
        .already_present = resp.is_already_present,
    };
 
    return resp;
}
 
FF HintingRawDB::get_leaf_value(world_state::MerkleTreeId tree_id, index_t leaf_index) const
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(tree_id);
    FF value = db.get_leaf_value(tree_id, leaf_index);
    GetLeafValueKey key = { tree_info, tree_id, leaf_index };
    merkle_hints.get_leaf_value_hints[key] =
        GetLeafValueHint{ .hint_key = tree_info, .tree_id = tree_id, .index = leaf_index, .value = value };
    return value;
}
 
IndexedLeaf<PublicDataLeafValue> HintingRawDB::get_leaf_preimage_public_data_tree(index_t leaf_index) const
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(world_state::MerkleTreeId::PUBLIC_DATA_TREE);
    IndexedLeaf<PublicDataLeafValue> preimage = db.get_leaf_preimage_public_data_tree(leaf_index);
 
    GetLeafPreimageKey key = { tree_info, leaf_index };
    merkle_hints.get_leaf_preimage_hints_public_data_tree[key] = GetLeafPreimageHint<PublicDataTreeLeafPreimage>{
        .hint_key = tree_info, .index = leaf_index, .leaf_preimage = preimage
    };
    return preimage;
}
 
IndexedLeaf<NullifierLeafValue> HintingRawDB::get_leaf_preimage_nullifier_tree(index_t leaf_index) const
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(world_state::MerkleTreeId::NULLIFIER_TREE);
    IndexedLeaf<NullifierLeafValue> preimage = db.get_leaf_preimage_nullifier_tree(leaf_index);
    GetLeafPreimageKey key = { tree_info, leaf_index };
    merkle_hints.get_leaf_preimage_hints_nullifier_tree[key] = GetLeafPreimageHint<NullifierTreeLeafPreimage>{
        .hint_key = tree_info, .index = leaf_index, .leaf_preimage = preimage
    };
    return preimage;
}
 
SequentialInsertionResult<PublicDataLeafValue> HintingRawDB::insert_indexed_leaves_public_data_tree(
    const PublicDataLeafValue& leaf_value)
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(world_state::MerkleTreeId::PUBLIC_DATA_TREE);
    SequentialInsertionResult<PublicDataLeafValue> result = db.insert_indexed_leaves_public_data_tree(leaf_value);
    // The underlying db should update its state post insertion:
    AppendOnlyTreeSnapshot state_after = db.get_tree_roots().public_data_tree;
 
    SequentialInsertHintPublicDataTreeKey key = { tree_info, world_state::MerkleTreeId::PUBLIC_DATA_TREE, leaf_value };
    BB_ASSERT(!result.low_leaf_witness_data.empty(), "Expected non-empty low_leaf_witness_data after insertion");
    BB_ASSERT(!result.insertion_witness_data.empty(), "Expected non-empty insertion_witness_data after insertion");
    SequentialInsertHint<PublicDataLeafValue> sequential_insert_hint = {
        .hint_key = tree_info,
        .tree_id = world_state::MerkleTreeId::PUBLIC_DATA_TREE,
        .leaf = leaf_value,
        .low_leaves_witness_data = result.low_leaf_witness_data.back(),
        .insertion_witness_data = result.insertion_witness_data.back(),
        .state_after = state_after
    };
    merkle_hints.sequential_insert_hints_public_data_tree[key] = sequential_insert_hint;
 
    return result;
}
 
SequentialInsertionResult<NullifierLeafValue> HintingRawDB::insert_indexed_leaves_nullifier_tree(
    const NullifierLeafValue& leaf_value)
{
    AppendOnlyTreeSnapshot tree_info = get_tree_info(world_state::MerkleTreeId::NULLIFIER_TREE);
    SequentialInsertionResult<NullifierLeafValue> result = db.insert_indexed_leaves_nullifier_tree(leaf_value);
    // The underlying db should update its state post insertion:
    auto state_after = db.get_tree_roots().nullifier_tree;
 
    SequentialInsertHintNullifierTreeKey key = { tree_info, world_state::MerkleTreeId::NULLIFIER_TREE, leaf_value };
    BB_ASSERT(!result.low_leaf_witness_data.empty(), "Expected non-empty low_leaf_witness_data after insertion");
    BB_ASSERT(!result.insertion_witness_data.empty(), "Expected non-empty insertion_witness_data after insertion");
    SequentialInsertHint<NullifierLeafValue> sequential_insert_hint = {
        .hint_key = tree_info,
        .tree_id = world_state::MerkleTreeId::NULLIFIER_TREE,
        .leaf = leaf_value,
        .low_leaves_witness_data = result.low_leaf_witness_data.back(),
        .insertion_witness_data = result.insertion_witness_data.back(),
        .state_after = state_after
    };
    merkle_hints.sequential_insert_hints_nullifier_tree[key] = sequential_insert_hint;
 
    return result;
}
 
void HintingRawDB::create_checkpoint()
{
    uint32_t old_checkpoint_id = db.get_checkpoint_id();
    // Update underlying db:
    db.create_checkpoint();
 
    // Store hint:
    merkle_hints.create_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = db.get_checkpoint_id(),
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
void HintingRawDB::commit_checkpoint()
{
    uint32_t old_checkpoint_id = db.get_checkpoint_id();
    // Update underlying db:
    db.commit_checkpoint();
    // Store hint:
    merkle_hints.commit_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = db.get_checkpoint_id(),
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
void HintingRawDB::revert_checkpoint()
{
    TreeSnapshots state_before = db.get_tree_roots();
    uint32_t old_checkpoint_id = db.get_checkpoint_id();
    // Update underlying db:
    db.revert_checkpoint();
    TreeSnapshots state_after = db.get_tree_roots();
    // Store hint:
    merkle_hints.revert_checkpoint_hints[checkpoint_action_counter] = {
        .action_counter = checkpoint_action_counter,
        .old_checkpoint_id = old_checkpoint_id,
        .new_checkpoint_id = db.get_checkpoint_id(),
        .state_before = state_before,
        .state_after = state_after,
    };
 
    // Update this db:
    checkpoint_action_counter++;
}
 
void HintingRawDB::pad_tree(world_state::MerkleTreeId tree_id, size_t num_leaves)
{
    // Padding the tree does not require any hints:
    db.pad_tree(tree_id, num_leaves);
}
 
void HintingRawDB::append_leaves(world_state::MerkleTreeId tree_id, std::span<const FF> leaves)
{
    AppendOnlyTreeSnapshot state_before = get_tree_info(tree_id);
    AppendLeavesHintKey append_key = { state_before, tree_id, std::vector<FF>(leaves.begin(), leaves.end()) };
 
    // Update underlying db:
    db.append_leaves(tree_id, leaves);
 
    merkle_hints.append_leaves_hints[append_key] =
        AppendLeavesHint{ .hint_key = state_before,
                          .state_after = get_tree_info(tree_id),
                          .tree_id = tree_id,
                          .leaves = std::vector<FF>(leaves.begin(), leaves.end()) };
}
 
void HintingRawDB::dump_hints(ExecutionHints& hints)
{
    std::ranges::transform(
        merkle_hints.get_sibling_path_hints,
        std::back_inserter(hints.get_sibling_path_hints),
        [](const auto& mapped_get_sibling_path_hint) { return mapped_get_sibling_path_hint.second; });
 
    std::ranges::transform(
        merkle_hints.get_previous_value_index_hints,
        std::back_inserter(hints.get_previous_value_index_hints),
        [](const auto& mapped_get_previous_value_index_hint) { return mapped_get_previous_value_index_hint.second; });
 
    std::ranges::transform(
        merkle_hints.get_leaf_preimage_hints_public_data_tree,
        std::back_inserter(hints.get_leaf_preimage_hints_public_data_tree),
        [](const auto& mapped_get_leaf_preimage_hint) { return mapped_get_leaf_preimage_hint.second; });
 
    std::ranges::transform(
        merkle_hints.get_leaf_preimage_hints_nullifier_tree,
        std::back_inserter(hints.get_leaf_preimage_hints_nullifier_tree),
        [](const auto& mapped_get_leaf_preimage_hint) { return mapped_get_leaf_preimage_hint.second; });
 
    std::ranges::transform(merkle_hints.get_leaf_value_hints,
                           std::back_inserter(hints.get_leaf_value_hints),
                           [](const auto& mapped_get_leaf_value_hint) { return mapped_get_leaf_value_hint.second; });
 
    std::ranges::transform(
        merkle_hints.sequential_insert_hints_public_data_tree,
        std::back_inserter(hints.sequential_insert_hints_public_data_tree),
        [](const auto& mapped_sequential_insert_hint) { return mapped_sequential_insert_hint.second; });
 
    std::ranges::transform(
        merkle_hints.sequential_insert_hints_nullifier_tree,
        std::back_inserter(hints.sequential_insert_hints_nullifier_tree),
        [](const auto& mapped_sequential_insert_hint) { return mapped_sequential_insert_hint.second; });
 
    std::ranges::transform(merkle_hints.append_leaves_hints,
                           std::back_inserter(hints.append_leaves_hints),
                           [](const auto& mapped_append_leaves_hint) { return mapped_append_leaves_hint.second; });
 
    std::ranges::transform(
        merkle_hints.create_checkpoint_hints,
        std::back_inserter(hints.create_checkpoint_hints),
        [](const auto& mapped_create_checkpoint_hint) { return mapped_create_checkpoint_hint.second; });
 
    std::ranges::transform(
        merkle_hints.commit_checkpoint_hints,
        std::back_inserter(hints.commit_checkpoint_hints),
        [](const auto& mapped_commit_checkpoint_hint) { return mapped_commit_checkpoint_hint.second; });
 
    std::ranges::transform(
        merkle_hints.revert_checkpoint_hints,
        std::back_inserter(hints.revert_checkpoint_hints),
        [](const auto& mapped_revert_checkpoint_hint) { return mapped_revert_checkpoint_hint.second; });
}
 
} // namespace bb::avm2::simulation