keccakf1600.test.cpp

Go to the documentation of this file.

#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/vm2/common/memory_types.hpp"
#include "barretenberg/vm2/constraining/flavor_settings.hpp"
#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
#include "barretenberg/vm2/generated/columns.hpp"
#include "barretenberg/vm2/generated/relations/keccak_memory.hpp"
#include "barretenberg/vm2/generated/relations/keccakf1600.hpp"
#include "barretenberg/vm2/testing/fixtures.hpp"
#include "barretenberg/vm2/testing/keccakf1600_fixture.test.hpp"
#include "barretenberg/vm2/tracegen/keccakf1600_trace.hpp"
#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
 
namespace bb::avm2::constraining {
namespace {
 
using tracegen::KeccakF1600TraceBuilder;
using tracegen::TestTraceContainer;
using C = Column;
 
using keccakf1600_relation = bb::avm2::keccakf1600<AvmFlavorSettings::FF>;
using keccak_memory_relation = bb::avm2::keccak_memory<AvmFlavorSettings::FF>;
 
TEST(KeccakF1600ConstrainingTest, EmptyRow)
{
    check_relation<keccakf1600_relation>(testing::empty_trace());
}
 
// Positive test of a single permutation with simulation and trace generation and checking interactions.
TEST(KeccakF1600ConstrainingTest, SinglewithSimulationAndTraceGenInteractions)
{
    TestTraceContainer trace;
 
    const MemoryAddress src_addr = 0;
    const MemoryAddress dst_addr = 200;
 
    testing::generate_keccak_trace(trace, { dst_addr }, { src_addr }, /*space_id=*/23);
 
    check_all_interactions<tracegen::KeccakF1600TraceBuilder>(trace);
    check_relation<keccakf1600_relation>(trace);
    check_relation<keccak_memory_relation>(trace);
}
 
// Positive test for multiple permutation calls with simulation and trace generation.
// We also check all interactions.
TEST(KeccakF1600ConstrainingTest, MultipleWithSimulationAndTraceGenInteractions)
{
    TestTraceContainer trace;
 
    constexpr size_t NUM_PERMUTATIONS = 3;
 
    std::vector<MemoryAddress> src_addresses(NUM_PERMUTATIONS);
    std::vector<MemoryAddress> dst_addresses(NUM_PERMUTATIONS);
 
    for (size_t k = 0; k < NUM_PERMUTATIONS; ++k) {
        src_addresses.at(k) = static_cast<MemoryAddress>(k * 200);
        dst_addresses.at(k) = static_cast<MemoryAddress>((k * 200) + 1000);
    }
 
    testing::generate_keccak_trace(trace, dst_addresses, src_addresses, /*space_id=*/79);
 
    check_all_interactions<tracegen::KeccakF1600TraceBuilder>(trace);
    check_relation<keccakf1600_relation>(trace);
    check_relation<keccak_memory_relation>(trace);
}
 
// Test tag error handling when a memory value has an incorrect tag.
// We test when the memory tag is not U64 for a read value at A[x=2][y=1].
// We check that the tag_error is 1 for this index (flattened index 7) and that
// we correctly propagate the error to the top.
TEST(KeccakF1600ConstrainingTest, TagErrorHandling)
{
    TestTraceContainer trace;
 
    const MemoryAddress src_addr = 0;
    const MemoryAddress dst_addr = 200;
    const uint16_t space_id = 79;
 
    // Standard Keccak layout: memory[(y * 5) + x] = A[x][y]
    // Position A[x=2][y=1] in the 5x5 matrix corresponds to index (1 * 5) + 2 = 7 in the flattened array
    const size_t error_offset = 7;
    const MemoryTag error_tag = MemoryTag::U32; // Using U32 instead of U64 to trigger error
 
    testing::generate_keccak_trace_with_tag_error(trace, dst_addr, src_addr, error_offset, error_tag, space_id);
 
    check_all_interactions<tracegen::KeccakF1600TraceBuilder>(trace);
    check_relation<keccakf1600_relation>(trace);
    check_relation<keccak_memory_relation>(trace);
}
 
// Test slice error handling when the src address is out of bounds.
TEST(KeccakF1600ConstrainingTest, SrcAddressOutOfBounds)
{
    TestTraceContainer trace;
 
    const MemoryAddress src_addr = AVM_HIGHEST_MEM_ADDRESS;
    const MemoryAddress dst_addr = 456;
    const uint16_t space_id = 23;
 
    testing::generate_keccak_trace_with_slice_error(trace, dst_addr, src_addr, space_id);
 
    check_all_interactions<tracegen::KeccakF1600TraceBuilder>(trace);
    check_relation<keccakf1600_relation>(trace);
    check_relation<keccak_memory_relation>(trace);
}
 
// Test slice error handling when the dst address is out of bounds.
TEST(KeccakF1600ConstrainingTest, DstAddressOutOfBounds)
{
    TestTraceContainer trace;
 
    const MemoryAddress src_addr = 123;
    const MemoryAddress dst_addr = AVM_HIGHEST_MEM_ADDRESS - AVM_KECCAKF1600_STATE_SIZE + 2;
    const uint16_t space_id = 23;
 
    testing::generate_keccak_trace_with_slice_error(trace, dst_addr, src_addr, space_id);
 
    check_all_interactions<tracegen::KeccakF1600TraceBuilder>(trace);
    check_relation<keccakf1600_relation>(trace);
    check_relation<keccak_memory_relation>(trace);
}
 
// Negative test: when sel_slice_write is active, round must equal AVM_KECCAKF1600_NUM_ROUNDS (24).
TEST(KeccakF1600ConstrainingTest, NegativeRoundCountAtWrite)
{
    TestTraceContainer trace = TestTraceContainer({ {
                                                        { C::precomputed_first_row, 1 },
                                                    },
                                                    {
                                                        { C::keccakf1600_sel, 1 },
                                                        { C::keccakf1600_sel_slice_write, 1 },
                                                        { C::keccakf1600_round, 23 },
                                                    } });
 
    EXPECT_THROW_WITH_MESSAGE(
        check_relation<keccakf1600_relation>(trace, keccakf1600_relation::SR_ROUND_COUNT_AT_WRITE),
        "ROUND_COUNT_AT_WRITE");
 
    // Setting round to 24 should satisfy the constraint.
    trace.set(C::keccakf1600_round, 1, 24);
    check_relation<keccakf1600_relation>(trace, keccakf1600_relation::SR_ROUND_COUNT_AT_WRITE);
}
 
// Negative test: sel cannot drop from 1 to 0 mid-block (i.e., without end == 1).
// Row 0: first_row=1, sel=1, start=1 (LATCH_CONDITION=1 via first_row)
// Row 1: sel=1, end=0 (mid-block row, sel must not drop to 0 here)
// Row 2: sel=0 (violates TRACE_CONTINUITY at row 1)
TEST(KeccakF1600ConstrainingTest, NegativeTraceContinuity)
{
    TestTraceContainer trace = TestTraceContainer({ {
                                                        { C::precomputed_first_row, 1 },
                                                        { C::keccakf1600_sel, 1 },
                                                        { C::keccakf1600_start, 1 },
                                                    },
                                                    {
                                                        { C::keccakf1600_sel, 1 },
                                                    },
                                                    {
                                                        { C::keccakf1600_sel, 0 },
                                                    } });
 
    // sel drops from 1 to 0 at row 1 without end == 1, so this should fail.
    EXPECT_THROW_WITH_MESSAGE(check_relation<keccakf1600_relation>(trace, keccakf1600_relation::SR_TRACE_CONTINUITY),
                              "TRACE_CONTINUITY");
 
    // Setting end=1 on row 1 should satisfy the constraint.
    trace.set(C::keccakf1600_end, 1, 1);
 
    check_relation<keccakf1600_relation>(trace, keccakf1600_relation::SR_TRACE_CONTINUITY);
}
 
} // namespace
} // namespace bb::avm2::constraining