feat: 754 Add WritableMessageDigest.digestInto method.

Signed-off-by: Ivan Malygin <ivan@swirldslabs.com>

Author: imalygin

pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/WritableMessageDigest.java

@@ -48,6 +48,26 @@ public byte[] digest() {
         return digest.digest();
     }
 
+    /**
+     * A delegate for the wrapped {@link MessageDigest#digest(byte[], int, int)} method.
+     *
+     * <p>The digest is written into {@code buf} starting at {@code offset}. The length used is
+     * {@link MessageDigest#getDigestLength()}, and {@link #position()} is reset to {@code 0},
+     * matching the behavior of {@link #digest()}.
+     *
+     * @param buf the destination buffer for the digest bytes
+     * @param offset the offset in {@code buf} where digest bytes are written
+     * @throws RuntimeException if writing the digest into the destination buffer fails
+     */
+    public void digestInto(final byte[] buf, final int offset) {
+        position = 0;
+        try {
+            digest.digest(buf, offset, digest.getDigestLength());
+        } catch (final java.security.DigestException e) {
+            throw new RuntimeException("Failed to write digest into buffer", e);
+        }
+    }
+
     @Override
     public void writeByte(byte b) throws BufferOverflowException, UncheckedIOException {
         digest.update(b);

pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/hashing/WritableMessageDigestTest.java

@@ -6,10 +6,10 @@
 
 import com.hedera.pbj.runtime.io.buffer.BufferedData;
 import com.hedera.pbj.runtime.io.buffer.Bytes;
-import com.hedera.pbj.runtime.io.buffer.RandomAccessData;
 import java.nio.ByteBuffer;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -66,10 +66,6 @@ private static Stream<byte[]> provideByteArrays() {
                 FULL_RANGE_ARRAY);
     }
 
-    private static Stream<Arguments> provideByteArrayArguments() {
-        return provideByteArrays().map(Arguments::of);
-    }
-
     @ParameterizedTest
     @MethodSource("provideByteArrays")
     void testWriteByteArray(byte[] array) {
@@ -155,8 +151,29 @@ void testWriteRandomAccessData(byte[] array) {
         final Bytes bytes = Bytes.wrap(array);
         final MessageDigest testDigest = buildDigest();
         final WritableMessageDigest wmd = new WritableMessageDigest(testDigest);
-        wmd.writeBytes((RandomAccessData) bytes);
+        wmd.writeBytes(bytes);
 
         assertArrayEquals(ctrlDigest.digest(), testDigest.digest());
     }
+
+    @ParameterizedTest
+    @MethodSource("provideByteArrays")
+    void testDigestInto(byte[] array) {
+        final MessageDigest ctrlDigest = buildDigest();
+        ctrlDigest.update(array);
+        final byte[] expectedDigest = ctrlDigest.digest();
+
+        final WritableMessageDigest wmd = new WritableMessageDigest(buildDigest());
+        wmd.writeBytes(array);
+        assertEquals(array.length, wmd.position());
+
+        final byte[] output = new byte[expectedDigest.length + 4];
+        Arrays.fill(output, (byte) 0x55);
+        wmd.digestInto(output, 2);
+
+        assertEquals(0, wmd.position());
+        assertArrayEquals(expectedDigest, Arrays.copyOfRange(output, 2, 2 + expectedDigest.length));
+        assertArrayEquals(new byte[] {(byte) 0x55, (byte) 0x55}, Arrays.copyOfRange(output, 0, 2));
+        assertArrayEquals(new byte[] {(byte) 0x55, (byte) 0x55}, Arrays.copyOfRange(output, 2 + expectedDigest.length, output.length));
+    }
 }