feat(verification): Hashing refactor for 0.68.x HAPI version (#1865)

Signed-off-by: Alfredo Gutierrez Grajeda <[email protected]>

Author: AlfredoG87

block-node/app/src/testFixtures/java/org/hiero/block/node/app/fixtures/blocks/BlockUtils.java

@@ -54,13 +54,6 @@ public static Block toBlock(BlockUnparsed block) {
      * Gets a SampleBlockInfo, out of the defined sample blocks enum.
      */
     public static SampleBlockInfo getSampleBlockInfo(SAMPLE_BLOCKS sampleBlocks) throws IOException, ParseException {
-        // JSON Option not working
-        // Parsing is coming empty.
-        //        BlockUnparsed jsonOrigin = BlockUnparsed.JSON.parse(Bytes.wrap(BlockUtils.class
-        //                .getModule()
-        //                .getResourceAsStream("test-blocks/" + "perf-10K-1731.blk.json")
-        //                .readAllBytes()));
-
         BlockUnparsed blockUnparsed;
         var stream = TestUtils.class.getModule().getResourceAsStream("test-blocks/" + sampleBlocks.blockName);
         try (final var gzipInputStream = new GZIPInputStream(stream)) {
@@ -87,16 +80,15 @@ public record SampleBlockInfo(Bytes blockRootHash, Long blockNumber, BlockUnpars
      * These blocks are used for testing purposes only.
      */
     public enum SAMPLE_BLOCKS {
-        HAPI_0_64_0_BLOCK_14(
-                "HAPI-0-64-0/000000000000000000000000000000000014.blk.gz",
-                "54dca69665741f13d8c956dffb3327edbe5d56e32d2bc66d6ce145a1e1b62fe61cddb74b19f17a5da9bb01933429d5e0",
-                14),
         HAPI_0_66_0_BLOCK_10(
                 "HAPI-0-66-0/000000000000000000000000000000000010.blk.gz",
-                "8d6d9004594f10f15518a2c6a7c5d473077f2a83a874a9489095adc0d0bf6b7c9f7e49b1e5430203e7234ebfd2880de2",
-                10);
+                "30783030", // dummy hash
+                10),
+        HAPI_0_68_0_BLOCK_14(
+                "HAPI-0-68-0/000000000000000000000000000000000014.blk.gz",
+                "d4924fe896fd32375ced195f29238f36b50f1a04d7b0e34e00b82758a2e9cabd37c98945181788e309d2c9588830bbcb",
+                14);
 
-        // VNymlmV0HxPYyVbf+zMn7b5dVuMtK8ZtbOFFoeG2L+Yc3bdLGfF6Xam7AZM0KdXg
         private final String blockName;
         private final Bytes blockHash;
         private final long blockNumber;

block-node/app/src/testFixtures/java/org/hiero/block/node/app/fixtures/blocks/SimpleTestBlockItemBuilder.java

@@ -8,8 +8,10 @@
 import com.hedera.hapi.block.stream.BlockItem;
 import com.hedera.hapi.block.stream.BlockItem.ItemOneOfType;
 import com.hedera.hapi.block.stream.BlockProof;
+import com.hedera.hapi.block.stream.TssSignedBlockProof;
 import com.hedera.hapi.block.stream.input.EventHeader;
 import com.hedera.hapi.block.stream.input.RoundHeader;
+import com.hedera.hapi.block.stream.output.BlockFooter;
 import com.hedera.hapi.block.stream.output.BlockHeader;
 import com.hedera.hapi.node.base.BlockHashAlgorithm;
 import com.hedera.hapi.node.base.SemanticVersion;
@@ -68,15 +70,16 @@ public static Bytes createRoundHeaderUnparsed(final long roundNumber) {
     }
 
     public static BlockProof createBlockProof(final long blockNumber) {
-        return new BlockProof(
-                blockNumber,
-                Bytes.wrap("previousBlockRootHash".getBytes()),
-                Bytes.wrap("startOfBlockStateRootHash".getBytes()),
-                Bytes.wrap("block_signature".getBytes()),
-                Collections.emptyList(),
-                new OneOf<>(
-                        BlockProof.VerificationReferenceOneOfType.VERIFICATION_KEY,
-                        Bytes.wrap("verificationKey".getBytes())));
+
+        TssSignedBlockProof.Builder tssBuildder =
+                TssSignedBlockProof.newBuilder().blockSignature(Bytes.wrap("block_signature".getBytes()));
+
+        BlockProof blockProof = BlockProof.newBuilder()
+                .block(blockNumber)
+                .signedBlockProof(tssBuildder)
+                .build();
+
+        return blockProof;
     }
 
     public static Bytes createBlockProofUnparsed(final long blockNumber) {
@@ -129,6 +132,28 @@ public static BlockItemUnparsed sampleBlockHeaderUnparsed(final long blockNumber
                 .build();
     }
 
+    public static BlockFooter createBlockFooter(final long blockNumber) {
+        return BlockFooter.newBuilder()
+                .previousBlockRootHash(Bytes.wrap("previous_block_root_hash".getBytes()))
+                .rootHashOfAllBlockHashesTree(Bytes.wrap("root_hash_of_all_blocks".getBytes()))
+                .startOfBlockStateRootHash(Bytes.wrap("start_block_state_root_hash".getBytes()))
+                .build();
+    }
+
+    public static Bytes createBlockFooterUnparsed(final long blockNumber) {
+        return BlockFooter.PROTOBUF.toBytes(createBlockFooter(blockNumber));
+    }
+
+    public static BlockItem sampleBlockFooter(final long blockNumber) {
+        return new BlockItem(new OneOf<>(ItemOneOfType.BLOCK_FOOTER, createBlockFooter(blockNumber)));
+    }
+
+    public static BlockItemUnparsed sampleBlockFooterUnparsed(final long blockNumber) {
+        return BlockItemUnparsed.newBuilder()
+                .blockFooter(Bytes.wrap(("block_footer_" + blockNumber).getBytes()))
+                .build();
+    }
+
     public static BlockItem sampleRoundHeader(final long roundNumber) {
         return new BlockItem(new OneOf<>(ItemOneOfType.ROUND_HEADER, createRoundHeader(roundNumber)));
     }
@@ -137,8 +162,8 @@ public static BlockItem sampleRoundHeader(final long roundNumber) {
      * Create an EventHeader with no parents and no signature middle bit.
      */
     public static BlockItem sampleLargeEventHeader() {
-        return new BlockItem(new OneOf<>(
-                ItemOneOfType.EVENT_HEADER, new EventHeader(EventCore.DEFAULT, Collections.emptyList(), false)));
+        return new BlockItem(
+                new OneOf<>(ItemOneOfType.EVENT_HEADER, new EventHeader(EventCore.DEFAULT, Collections.emptyList())));
     }
 
     public static BlockItemUnparsed sampleRoundHeaderUnparsed(final long roundNumber) {
@@ -191,7 +216,8 @@ public static BlockItem[] createNumberOfVerySimpleBlocks(final long startBlockNu
             final int i = (blockNumber - (int) startBlockNumber) * 3;
             blockItems[i] = sampleBlockHeader(blockNumber);
             blockItems[i + 1] = sampleRoundHeader(blockNumber * 10L);
-            blockItems[i + 2] = sampleBlockProof(blockNumber);
+            blockItems[i + 2] = sampleBlockFooter(blockNumber * 10L);
+            blockItems[i + 2] = sampleBlockProof(blockNumber); // TODO Improve proof generation
         }
         return blockItems;
     }

block-node/app/src/testFixtures/resources/test-blocks/HAPI-0-64-0/000000000000000000000000000000000014.blk.gz

@@ -21,6 +21,5 @@ testModuleInfo {
     requires("org.mockito")
     requires("org.testcontainers")
     requires("io.minio")
-    requires("junit")
     requires("org.hiero.block.protobuf.pbj")
 }

block-node/app/src/testFixtures/resources/test-blocks/HAPI-0-68-0/000000000000000000000000000000000014.blk.gz

@@ -3,8 +3,8 @@
 
 import static org.hiero.block.node.app.fixtures.blocks.SimpleTestBlockItemBuilder.createNumberOfLargeBlocks;
 import static org.hiero.block.node.app.fixtures.blocks.SimpleTestBlockItemBuilder.createNumberOfVerySimpleBlockAccessors;
-import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import com.github.luben.zstd.Zstd;

block-node/app/src/testFixtures/resources/test-blocks/generated-10.blk.gz

@@ -10,6 +10,7 @@
 import com.hedera.hapi.block.stream.BlockItem;
 import com.hedera.hapi.block.stream.BlockItem.ItemOneOfType;
 import com.hedera.hapi.block.stream.BlockProof;
+import com.hedera.hapi.block.stream.TssSignedBlockProof;
 import com.hedera.hapi.block.stream.input.RoundHeader;
 import com.hedera.hapi.block.stream.output.BlockHeader;
 import com.hedera.hapi.node.base.BlockHashAlgorithm;
@@ -18,7 +19,6 @@
 import com.hedera.pbj.runtime.OneOf;
 import com.hedera.pbj.runtime.ParseException;
 import com.hedera.pbj.runtime.io.buffer.Bytes;
-import java.util.Collections;
 import java.util.List;
 import org.hiero.block.internal.BlockUnparsed;
 import org.hiero.block.node.spi.historicalblocks.BlockAccessor.Format;
@@ -41,15 +41,12 @@ public class BlockAccessorTest {
             new BlockItem(new OneOf<>(ItemOneOfType.ROUND_HEADER, new RoundHeader(827))),
             new BlockItem(new OneOf<>(
                     ItemOneOfType.BLOCK_PROOF,
-                    new BlockProof(
-                            0,
-                            Bytes.wrap("previousBlockRootHash".getBytes()),
-                            Bytes.wrap("startOfBlockStateRootHash".getBytes()),
-                            Bytes.wrap("block_signature".getBytes()),
-                            Collections.emptyList(),
-                            new OneOf<>(
-                                    BlockProof.VerificationReferenceOneOfType.VERIFICATION_KEY,
-                                    Bytes.wrap("verificationKey".getBytes())))))));
+                    BlockProof.newBuilder()
+                            .block(0)
+                            .signedBlockProof(TssSignedBlockProof.newBuilder()
+                                    .blockSignature(Bytes.wrap("signature"))
+                                    .build())
+                            .build()))));
     private static final Bytes SAMPLE_BLOCK_PROTOBUF_BYTES = Block.PROTOBUF.toBytes(SAMPLE_BLOCK);
     private static final Bytes SAMPLE_BLOCK_ZSTD_PROTOBUF_BYTES =
             Bytes.wrap(Zstd.compress(Block.PROTOBUF.toBytes(SAMPLE_BLOCK).toByteArray()));

block-node/base/build.gradle.kts

@@ -5,13 +5,14 @@
 import java.util.Objects;
 import org.hiero.block.common.utils.Preconditions;
 import org.hiero.block.node.spi.blockmessaging.BlockSource;
+import org.hiero.block.node.verification.session.impl.DummyVerificationSession;
 import org.hiero.block.node.verification.session.impl.ExtendedMerkleTreeSession;
-import org.hiero.block.node.verification.session.impl.PreviewSimpleHashSession;
 
 /**
  * Factory for creating {@link VerificationSession} instances based on the requested HAPI version.
  */
 public final class HapiVersionSessionFactory {
+    private static final SemanticVersion V_0_69_0 = semanticVersion(0, 69, 0);
     private static final SemanticVersion V_0_68_0 = semanticVersion(0, 68, 0);
     private static final SemanticVersion V_0_64_0 = semanticVersion(0, 64, 0);
 
@@ -33,14 +34,22 @@ public static VerificationSession createSession(
         Objects.requireNonNull(hapiVersion, "hapiVersion cannot be null");
         Preconditions.requireWhole(blockNumber, "blockNumber must be >= 0");
 
+        // TODO, before going live we should remove the Dummy Implementation.
+        if (isGreaterThanOrEqual(hapiVersion, V_0_69_0)) {
+            return new DummyVerificationSession(blockNumber, blockSource);
+        }
+
         if (isGreaterThanOrEqual(hapiVersion, V_0_68_0)) {
-            return new ExtendedMerkleTreeSession(blockNumber, blockSource, "extraBytesPlaceholder");
-        } else if (isGreaterThanOrEqual(hapiVersion, V_0_64_0)) {
-            return new PreviewSimpleHashSession(blockNumber, blockSource);
-        } else {
-            final String unsupportedMessage = "Unsupported HAPI version: %s (supported from 0.64.0 and up)";
-            throw new IllegalArgumentException(unsupportedMessage.formatted(toShortString(hapiVersion)));
+            return new ExtendedMerkleTreeSession(blockNumber, blockSource);
         }
+
+        // TODO, before going live we should remove the Dummy Implementation.
+        if (isGreaterThanOrEqual(hapiVersion, V_0_64_0)) {
+            return new DummyVerificationSession(blockNumber, blockSource);
+        }
+
+        throw new IllegalArgumentException(
+                "Unsupported HAPI version: %s (supported from 0.64.0 and up)".formatted(toShortString(hapiVersion)));
     }
 
     /** v >= w ? (lexicographic by major, minor, patch) */

block-node/base/src/test/java/org/hiero/block/node/base/tar/TaredBlockIteratorTest.java

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+package org.hiero.block.node.verification.session.impl;
+
+import static java.lang.System.Logger.Level.INFO;
+import static java.lang.System.Logger.Level.TRACE;
+
+import com.hedera.pbj.runtime.ParseException;
+import com.hedera.pbj.runtime.io.buffer.Bytes;
+import java.util.ArrayList;
+import java.util.List;
+import org.hiero.block.internal.BlockItemUnparsed;
+import org.hiero.block.internal.BlockUnparsed;
+import org.hiero.block.node.spi.blockmessaging.BlockSource;
+import org.hiero.block.node.spi.blockmessaging.VerificationNotification;
+import org.hiero.block.node.verification.session.VerificationSession;
+
+// TODO, before going live we should remove the Dummy Implementation.
+/**
+ * Dummy implementation of VerificationSession for testing purposes.
+ * It simply collects block items and returns a successful verification notification
+ * if the last block item has a block proof.
+ */
+public class DummyVerificationSession implements VerificationSession {
+    private final System.Logger LOGGER = System.getLogger(getClass().getName());
+
+    /** The block number being verified. */
+    protected final long blockNumber;
+
+    /** The source of the block, used to construct the final notification. */
+    private final BlockSource blockSource;
+
+    /**
+     * The block items for the block this session is responsible for. We collect them here so we can provide the
+     * complete block in the final notification.
+     */
+    protected final List<BlockItemUnparsed> blockItems = new ArrayList<>();
+
+    public DummyVerificationSession(final long blockNumber, final BlockSource blockSource) {
+        this.blockNumber = blockNumber;
+        this.blockSource = blockSource;
+        LOGGER.log(INFO, "Created DummyVerificationSession for block {0}", blockNumber);
+    }
+
+    @Override
+    public VerificationNotification processBlockItems(List<BlockItemUnparsed> blockItems) throws ParseException {
+        this.blockItems.addAll(blockItems);
+        LOGGER.log(TRACE, "Processed {0} block items for block {1}", blockItems.size(), blockNumber);
+        if (blockItems.getLast().hasBlockProof()) {
+            BlockUnparsed block =
+                    BlockUnparsed.newBuilder().blockItems(this.blockItems).build();
+            Bytes blockHash = Bytes.wrap("0x00");
+            LOGGER.log(TRACE, "Returning always True verification notification for block {0}", blockNumber);
+            return new VerificationNotification(true, blockNumber, blockHash, block, blockSource);
+        }
+        return null;
+    }
+}