refact: add tests for new get_proof slicing

Author: diegonehab

src/Makefile

@@ -202,7 +202,7 @@ relwithdebinfo=yes
 endif
 
 ifeq ($(coverage),yes)
-OPTFLAGS+=-Og -g -fno-omit-frame-pointer -fno-dce -fno-inline
+OPTFLAGS+=-Og -g -fno-omit-frame-pointer -fno-inline
 DEFS+=-DCODE_COVERAGE
 else ifeq ($(relwithdebinfo),yes)
 OPTFLAGS+=-O2 -g
@@ -327,7 +327,7 @@ ifeq ($(coverage),yes)
 ifeq ($(COVERAGE_TOOLCHAIN),gcc)
 CC=gcc
 CXX=g++
-CXXFLAGS+=--coverage
+CXXFLAGS+=--coverage -fno-dce
 LDFLAGS+=--coverage
 else ifeq ($(COVERAGE_TOOLCHAIN),clang)
 CC=clang

tests/lua/cartesi/tests/util.lua

@@ -243,6 +243,48 @@ function test_util.check_proof(proof, hash_fn)
     return hash == proof.root_hash
 end
 
+function test_util.slice_proof(proof, new_log2_root_size, new_log2_target_size, hash_fn)
+    assert(hash_fn, "hash_fn is nil")
+    assert(new_log2_root_size <= proof.log2_root_size, "log2_root_size is too large")
+    assert(new_log2_target_size >= proof.log2_target_size, "log2_target_size is too small")
+    assert(new_log2_target_size <= new_log2_root_size, "log2_target_size > log2_root_size")
+    -- Bubble up from original target to new target size
+    local hash = proof.target_hash
+    for log2_size = proof.log2_target_size, new_log2_target_size - 1 do
+        local bit = (proof.target_address & (1 << log2_size)) ~= 0
+        local first, second
+        if bit then
+            first, second = proof.sibling_hashes[log2_size - proof.log2_target_size + 1], hash
+        else
+            first, second = hash, proof.sibling_hashes[log2_size - proof.log2_target_size + 1]
+        end
+        hash = cartesi[hash_fn](first, second)
+    end
+    local sliced = {
+        log2_root_size = new_log2_root_size,
+        log2_target_size = new_log2_target_size,
+        target_hash = hash,
+        target_address = (proof.target_address >> new_log2_target_size) << new_log2_target_size,
+        sibling_hashes = {},
+    }
+    -- Copy sibling hashes and continue bubbling up to compute root hash
+    for log2_size = new_log2_target_size, new_log2_root_size - 1 do
+        local sibling = proof.sibling_hashes[log2_size - proof.log2_target_size + 1]
+        sliced.sibling_hashes[log2_size - new_log2_target_size + 1] = sibling
+        local bit = (proof.target_address & (1 << log2_size)) ~= 0
+        local first, second
+        if bit then
+            first, second = sibling, hash
+        else
+            first, second = hash, sibling
+        end
+        hash = cartesi[hash_fn](first, second)
+    end
+    sliced.root_hash = hash
+    assert(test_util.check_proof(sliced, hash_fn), "produced invalid sliced proof")
+    return sliced
+end
+
 function test_util.align(v, el)
     return (v >> el << el)
 end

tests/lua/spec-hash-tree.lua

@@ -266,6 +266,44 @@ describe("hash tree", function()
                 end
             end)
 
+            it("should have consistent sliced proofs", function()
+                local word_index = 0
+                for _, p in ipairs(interesting_pages) do
+                    local page, range = table.unpack(p)
+                    local range_log2_size = math.ceil(math.log(bit_ceil(range.length), 2))
+                    local interesting_sizes = {
+                        LOG2_WORD_SIZE,
+                        LOG2_WORD_SIZE + 1,
+                        LOG2_PAGE_SIZE - 1,
+                        LOG2_PAGE_SIZE,
+                        LOG2_PAGE_SIZE + 1,
+                        range_log2_size - 1,
+                        range_log2_size,
+                        range_log2_size + 1,
+                        LOG2_ROOT_SIZE,
+                    }
+                    local address = get_aligned_address(page + (word_index * WORD_SIZE % PAGE_SIZE), LOG2_WORD_SIZE)
+                    word_index = word_index + 17
+                    local full_proof = machine:get_proof(address, LOG2_WORD_SIZE)
+                    for _, log2_root_size in ipairs(interesting_sizes) do
+                        for _, log2_target_size in ipairs(interesting_sizes) do
+                            if log2_target_size >= LOG2_WORD_SIZE
+                                and log2_root_size > log2_target_size
+                                and log2_root_size <= LOG2_ROOT_SIZE
+                            then
+                                local sproof = util.slice_proof(
+                                    full_proof, log2_root_size, log2_target_size, hash_function
+                                )
+                                expect_consistent_proof(sproof, hash_function)
+                                local aligned = get_aligned_address(address, log2_target_size)
+                                local mproof = machine:get_proof(aligned, log2_target_size, log2_root_size)
+                                expect.equal(sproof, mproof)
+                            end
+                        end
+                    end
+                end
+            end)
+
             it("should have consistent proofs for all words (and up) in a few pages", function()
                 local clone_machine <close> = make_machine({ phtc_size = 1 })
                 clone_machine:run()

tests/misc/Makefile

@@ -111,7 +111,7 @@ all: $(BUILDDIR)/test-machine-c-api
 	@exit 1
 
 $(BUILDDIR)/test-machine-c-api: test-machine-c-api.o ../../src/libcartesi.a ../../src/libcartesi_hash_tree.a
-	$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBCARTESI_LIBS) $(OMP_LIB)
+	$(CXX) -o $@ $^ $(CXXFLAGS) $(LDFLAGS) $(LIBCARTESI_LIBS) $(OMP_LIB)
 
 %.o: %.cpp
 	$(CXX) $(CXXFLAGS) -c -o $@ $<