2026-08-20 21:19:17 +09:00
24 changed files with 2532 additions and 536 deletions
@@ -6,9 +6,12 @@ Thumbs.db
 .netrwhist
 .nvimlog
 .idea/
+.artifacts/
 *.iml
 .gradle/
 local.properties
 Captures/
 .externalNativeBuild/
 temp
+erl_crash.dump
+*.class
@@ -2,6 +2,32 @@

 Java libraries for the Gajumaru

+
+## Purpose
+
+gm-java provides the basic functionality required to interact with the [Gajumaru](https://gajumaru./io)
+blockchain system. This includes serialization, function wrappers for Gajumaru node endpoint calls,
+handling of GRIDS URLs, formatting of monetary values, any cryptographic functions not covered in
+standard Java libraries, and some network functionality necessary to interact smoothly with
+Gajumaru chains (Groot and AC networks).
+
+This codebase may *not* include references to third-party libraries, may *not* permit un-zeroed
+byte values to be left on the heap until the JVM eventually decides to garbage collect them,
+and may *not* build up a big, gnarly, inheritance-heavy OOPsy object hierarchy.
+
+Classes should generally be structured as `final` classes of functions that operate over data
+that can be expressed as Java primitives, most commonly `byte[]` and some form of `int` or
+occasionally `BigInteger`. 
+
+`BigInteger` is not permitted in cryptographic operations, as it leaves potentially sensitive
+artifacts scattered all throughout the heap and can occasionally make the garbage collector
+go bananas when performing heavy math operations. `BigInteger` is excellent, however, for things
+like representing currency values in Pucks.
+
+All forms of floating-point arithmetic are forbidden in all currency calculations. The Gajumaru
+does not have floats, and they do not exist at all in the Sophia language.
+
+
 ## Terms

 Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
@@ -14,11 +14,10 @@ rm -f "$project_dir/Testinator.class"

 # Build every .java file
 find "$project_dir/src/main/java" -name "*.java" | xargs javac \
-    -source 21 \
-    -target 21 \
+    --release 21 \
    -d "$project_dir/build/classes"

 # Build the Testinator thingy
-javac -cp "build/classes" -d build src/Testinator.java
+javac -cp "build/classes" -d build test/Testinator.java

 echo "Bytecode in $project_dir/build/classes/"
@@ -1,172 +0,0 @@
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Base64;
-import java.util.ArrayList;
-import java.util.List;
-import java.math.BigInteger;
-
-import swiss.qpq.gajumaru.core.encoding.Base58;
-import swiss.qpq.gajumaru.core.encoding.RLP;
-import swiss.qpq.gajumaru.core.formatting.GajuFormat;
-
-public class Testinator {
-    public static void main(String[] args) {
-        if (args.length != 2) {
-            System.out.println("Error: Provide the test suite name and the working dir path.");
-            System.exit(1);
-        }
-
-        try {
-            switch (args[0]) {
-                case "base64" -> {
-                    System.out.print(base64(args[1]));
-                }
-                case "base58" -> {
-                    System.out.print(base58(args[1]));
-                }
-                case "base58_check" -> {
-                    System.out.print(base58_check(args[1]));
-                }
-                case "rlp" -> {
-                    System.out.print(rlp(args[1]));
-                }
-                case "rlp_stream" -> {
-                    System.out.print(rlp_stream(args[1]));
-                }
-                case "rlp_fail" -> {
-                    System.out.print(rlp_fail(args[1]));
-                }
-                case "gaju_format" -> {
-                    System.out.print(gaju_format(args[1]));
-                }
-            }
-        } catch (Exception e) {
-            System.err.println("Error: " + e.getMessage());
-            System.exit(1);
-        }
-    }
-
-    private static String base64(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "base64.test");
-        Path encPath  = Path.of(workingPath, "base64.java.txt");
-        Path decPath  = Path.of(workingPath, "base64.java.back");
-        byte[] rawB   = Files.readAllBytes(testPath);
-        byte[] encB   = Base64.getEncoder().encode(rawB);
-        Files.write(encPath, encB);
-        byte[] readE  = Files.readAllBytes(encPath);
-        byte[] decB   = Base64.getDecoder().decode(readE);
-        Files.write(decPath, decB);
-        return encPath.toString() + " " + decPath.toString();
-    }
-
-    private static String base58(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "base58.test");
-        Path encPath  = Path.of(workingPath, "base58.java.txt");
-        Path decPath  = Path.of(workingPath, "base58.java.back");
-        byte[] rawB   = Files.readAllBytes(testPath);
-        String encS   = Base58.encode(rawB);
-        Files.write(encPath, encS.getBytes());
-        byte[] readE  = Files.readAllBytes(encPath);
-        String readS  = new String(readE);
-        byte[] decB   = Base58.decode(readS);
-        Files.write(decPath, decB);
-        return encPath.toString() + " " + decPath.toString();
-    }
-
-    private static String base58_check(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "base58_check.test");
-        Path encPath  = Path.of(workingPath, "base58_check.java.txt");
-        Path decPath  = Path.of(workingPath, "base58_check.java.back");
-        byte[] rawB   = Files.readAllBytes(testPath);
-        String encS   = Base58.checkEncode(rawB);
-        Files.write(encPath, encS.getBytes());
-        byte[] readE  = Files.readAllBytes(encPath);
-        String readS  = new String(readE);
-        byte[] decB   = Base58.checkDecode(readS);
-        Files.write(decPath, decB);
-        return encPath.toString() + " " + decPath.toString();
-    }
-
-    private static String rlp(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "rlp.test");
-        Path resPath  = Path.of(workingPath, "rlp.java.back");
-        byte[] encB   = Files.readAllBytes(testPath);
-        
-        RLP.RLP_Data decRLP = RLP.decode(encB);
-        
-        RLP.RLP_List root = decRLP.asList();
-        RLP.RLP_List sub  = root.getItems().get(1).asList();
-        byte[] anchor     = sub.getItems().get(1).asItem().getBytes();
-        
-        byte[] reEnc = RLP.encode(decRLP);
-        Files.write(resPath, reEnc);
-        
-        return new String(anchor) + "|" + resPath.toString();
-    }
-
-    private static String rlp_stream(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "rlp_stream.test");
-        byte[] buffer = Files.readAllBytes(testPath);
-        
-        List<String> hashes = new ArrayList<>();
-        int offset = 0;
-        while (offset < buffer.length) {
-            RLP.DecodeResult res = RLP.decodeFrom(buffer, offset);
-            hashes.add(Integer.toString(res.data().hashCode())); // Just to verify we got objects
-            offset += res.consumed();
-        }
-        return Integer.toString(hashes.size());
-    }
-
-    private static String rlp_fail(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "rlp_fail.test");
-        byte[] buffer = Files.readAllBytes(testPath);
-        try {
-            RLP.decode(buffer);
-            return "SUCCESS";
-        } catch (RLP.RLPException e) {
-            return "RLP_EXCEPTION: " + e.getMessage();
-        } catch (Exception e) {
-            return "OTHER_EXCEPTION: " + e.getClass().getSimpleName();
-        }
-    }
-
-    private static String gaju_format(String workingPath) throws IOException {
-        Path testPath = Path.of(workingPath, "gaju_format.test");
-        Path resPath  = Path.of(workingPath, "gaju_format.java.txt");
-        List<String> lines   = Files.readAllLines(testPath);
-        List<String> results = new ArrayList<>();
-        
-        for (String line : lines) {
-            if (line.trim().isEmpty()) continue;
-            String[] p = line.split("\\|");
-            String op  = p[0];
-            switch (op) {
-                case "amount" -> {
-                    GajuFormat.Type style = GajuFormat.Type.valueOf(p[1]);
-                    GajuFormat.Unit unit  = GajuFormat.Unit.valueOf(p[2]);
-                    char sep = p[3].charAt(0);
-                    int span = Integer.parseInt(p[4]);
-                    BigInteger val = new BigInteger(p[5]);
-                    results.add(GajuFormat.amount(new GajuFormat.FormatSpec(style, unit, sep, span), val));
-                }
-                case "approx" -> {
-                    GajuFormat.Type style = GajuFormat.Type.valueOf(p[1]);
-                    GajuFormat.Unit unit  = GajuFormat.Unit.valueOf(p[2]);
-                    char sep = p[3].charAt(0);
-                    int span = Integer.parseInt(p[4]);
-                    BigInteger val = new BigInteger(p[5]);
-                    int prec = Integer.parseInt(p[6]);
-                    results.add(GajuFormat.approxAmount(new GajuFormat.FormatSpec(style, unit, sep, span), val, prec));
-                }
-                case "read" -> {
-                    byte[] b = GajuFormat.read(p[1]);
-                    results.add(new BigInteger(b).toString());
-                }
-            }
-        }
-        Files.write(resPath, results);
-        return resPath.toString();
-    }
-}
@@ -1,24 +0,0 @@
-# GM Java <-> Erlang Tests
-
-The core Java libraries are all written as transform functions over data.
-There is little point, therefore, in obsessing over "unit tests" and "regression testing" of Java code in Java when we have cannonical code in Erlang.
-
-The purpose of this utility is to instead test the Java libraries agains the Erlang libraries directly.
-
-
-## How to run
-
-In the current directory simply run `zx runlocal` and the report map will be printed to the screen and random test data will be in the `temp/` directory.
-
-To run a specific test suite run `zx runlocal [module names]`.
-
-To list module names, run `zx runlocal list`.
-
-
-## Where things are
-
-The test cases are all generated in gmt.erl, generally based on randomized but valid data that are fed to reference Erlang implementations.
-The input to and output from each test is recorded to disk in the `temp/` dir.
-The inputs are then read in by equivalent Java functions and the output is then compared.
-
-For a test case to pass the outputs must be identical.
@@ -1,328 +0,0 @@
-%%% @doc
-%%% Gajumaru Java Lib Tester: gmt
-%%%
-%%% This module provides an inter-language test suite for the Gajumaru core
-%%% Java libraries. It tests the Java implementation against the canonical
-%%% Erlang implementation by generating random test vectors and comparing
-%%% the outputs.
-%%% @end
-
-module(gmt).
-vsn("0.1.0").
-author("Craig Everett <craigeverett@qpq.swiss>").
-copyright("Craig Everett <craigeverett@qpq.swiss>").
-license("LGPL-3.0-or-later").
-
-export([start/1]).
-
-
-%%% Logic
-
-mods() ->
-    #{"base64"       => fun base64/0,
-      "base58"       => fun base58/0,
-      "base58_check" => fun base58_check/0,
-      "rlp"          => fun rlp/0,
-      "rlp_stream"   => fun rlp_stream/0,
-      "rlp_fail"     => fun rlp_fail/0,
-      "gaju_format"  => fun gaju_format/0}.
-
-
-start([]) ->
-    Tests = mods(),
-    ok = run(Tests),
-    zx:silent_stop();
-start(["list"]) ->
-    ok = io:format("Available tests:~n"),
-    ok = lists:foreach(fun display/1, maps:keys(mods())),
-    zx:silent_stop();
-start(Mods) ->
-    Available = mods(),
-    Tests = maps:with(Mods, Available),
-    ok =
-        case maps:size(Tests) =:= length(Mods) of
-            true ->
-                run(Tests);
-            false ->
-                NotMods = lists:subtract(Mods, maps:keys(Available)),
-                ok = io:format("The following arguments are not testable module names:~n"),
-                lists:foreach(fun display/1, NotMods)
-        end,
-    zx:silent_stop().
-
-display(Name) ->
-    io:format("  ~ts~n", [Name]).
-
-run(Tests) ->
-    {ok, Cwd} = file:get_cwd(),
-    ok =
-        case filename:basename(Cwd) of
-            "test" -> file:set_cwd("..");
-            _      -> ok
-        end,
-    ok = clean(),
-    ok = build(),
-    Results = maps:map(fun run/2, Tests),
-    io:format("Results:~n ~tp~n", [Results]).
-
-run(Name, Test) ->
-    ok = io:format("~nRunning: ~ts...~n", [Name]),
-    Test().
-
-clean() ->
-    Temp = "test/temp",
-    lists:foreach(fun(D) -> ok = clean(D) end, [Temp]).
-
-clean(Dir) ->
-    case file:del_dir_r(Dir) of
-        ok              -> ok;
-        {error, enoent} -> ok;
-        Error           -> Error
-    end.
-
-build() ->
-    Out = os:cmd("bin/compile"),
-    io:format("Compile: ~ts", [Out]).
-
-temp_dir() ->
-    {ok, Cwd} = file:get_cwd(),
-    filename:join(Cwd, "test/temp").
-
-trim(S) ->
-    Unprintable = fun(C) -> C =< 32 end,
-    lists:reverse(lists:dropwhile(Unprintable, lists:reverse(lists:dropwhile(Unprintable, S)))).
-
-
-
-%%% Test Modules
-
-base64() ->
-    Temp = temp_dir(),
-    TestFile = filename:join(Temp, "base64.test"),
-    ConvFile = filename:join(Temp, "base64.erlang.txt"),
-    ok = filelib:ensure_dir(TestFile),
-    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
-    {ok, B} = file:read_file(TestFile),
-    Base64 = base64:encode(B),
-    ok = file:write_file(ConvFile, Base64),
-    Run = "bin/run base64 " ++ Temp,
-    Out = trim(os:cmd(Run)),
-    [JEnc, JDec] = string:split(Out, " "),
-    {ok, EEncB} = file:read_file(ConvFile),
-    {ok, JEncB} = file:read_file(JEnc),
-    EHash = crypto:hash(sha512, EEncB),
-    JHash = crypto:hash(sha512, JEncB),
-    {ok, EDecB} = file:read_file(TestFile),
-    {ok, JDecB} = file:read_file(JDec),
-    EBinHash = crypto:hash(sha512, EDecB),
-    JBinHash = crypto:hash(sha512, JDecB),
-    EHash =:= JHash andalso EBinHash =:= JBinHash.
-
-
-base58() ->
-    Temp = temp_dir(),
-    TestFile = filename:join(Temp, "base58.test"),
-    ConvFile = filename:join(Temp, "base58.erlang.txt"),
-    ok = filelib:ensure_dir(TestFile),
-    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
-    {ok, B} = file:read_file(TestFile),
-    Base58 = base58:binary_to_base58(B),
-    ok = file:write_file(ConvFile, Base58),
-    Run = "bin/run base58 " ++ Temp,
-    Out = trim(os:cmd(Run)),
-    [JEnc, JDec] = string:split(Out, " "),
-    {ok, EEncB} = file:read_file(ConvFile),
-    {ok, JEncB} = file:read_file(JEnc),
-    EHash = crypto:hash(sha512, EEncB),
-    JHash = crypto:hash(sha512, JEncB),
-    {ok, EDecB} = file:read_file(TestFile),
-    {ok, JDecB} = file:read_file(JDec),
-    EBinHash = crypto:hash(sha512, EDecB),
-    JBinHash = crypto:hash(sha512, JDecB),
-    EHash =:= JHash andalso EBinHash =:= JBinHash.
-
-
-base58_check() ->
-    Temp = temp_dir(),
-    TestFile = filename:join(Temp, "base58_check.test"),
-    ConvFile = filename:join(Temp, "base58_check.erlang.txt"),
-    ok = filelib:ensure_dir(TestFile),
-    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
-    {ok, B} = file:read_file(TestFile),
-    Checksum = binary:part(crypto:hash(sha256, crypto:hash(sha256, B)), 0, 4),
-    Base58C = base58:binary_to_base58(<<B/binary, Checksum/binary>>),
-    ok = file:write_file(ConvFile, Base58C),
-    Run = "bin/run base58_check " ++ Temp,
-    Out = trim(os:cmd(Run)),
-    [JEnc, JDec] = string:split(Out, " "),
-    {ok, EEncB} = file:read_file(ConvFile),
-    {ok, JEncB} = file:read_file(JEnc),
-    EHash = crypto:hash(sha512, EEncB),
-    JHash = crypto:hash(sha512, JEncB),
-    {ok, EDecB} = file:read_file(TestFile),
-    {ok, JDecB} = file:read_file(JDec),
-    EBinHash = crypto:hash(sha512, EDecB),
-    JBinHash = crypto:hash(sha512, JDecB),
-    EHash =:= JHash andalso EBinHash =:= JBinHash.
-
-
-rlp() ->
-    Temp = temp_dir(),
-    Anchor = <<"I thought what I'd do was, I'd pretend I was one of those deaf-mutes.">>,
-    Data =
-        [rand:bytes(rand:uniform(20)),
-         [rand:bytes(rand:uniform(20)),
-          Anchor,
-          rand:bytes(rand:uniform(20)),
-          rand:bytes(rand:uniform(5000))],
-         rand:bytes(rand:uniform(2000))],
-    RLP = gmser_rlp:encode(Data),
-    RLP_File = filename:join(Temp, "rlp.test"),
-    ok = filelib:ensure_dir(RLP_File),
-    ok = file:write_file(RLP_File, RLP),
-    Run = "bin/run rlp " ++ Temp,
-    Out = trim(os:cmd(Run)),
-    case string:split(Out, "|") of
-        [Found, JPath] ->
-            JPathTrimmed = trim(JPath),
-            {ok, EEncB} = file:read_file(RLP_File),
-            case file:read_file(JPathTrimmed) of
-                {ok, JEncB} ->
-                    EHash = crypto:hash(sha512, EEncB),
-                    JHash = crypto:hash(sha512, JEncB),
-                    EHash =:= JHash andalso Found =:= unicode:characters_to_list(Anchor);
-                {error, R} ->
-                    io:format("Failed to read RLP Java result: ~tp (Path: ~tp)~n", [R, JPathTrimmed]),
-                    false
-            end;
-        _ ->
-            io:format("RLP output mismatch: ~tp~n", [Out]),
-            false
-    end.
-
-
-rlp_stream() ->
-    Temp     = temp_dir(),
-    TestFile = filename:join(Temp, "rlp_stream.test"),
-    ok       = filelib:ensure_dir(TestFile),
-    Data     = [rand:bytes(rand:uniform(100)) || _ <- lists:seq(1, 10)],
-    RLP      = << <<(gmser_rlp:encode(D))/binary>> || D <- Data >>,
-    ok       = file:write_file(TestFile, RLP),
-    Run      = "bin/run rlp_stream " ++ Temp,
-    Out      = trim(os:cmd(Run)),
-    Out =:= "10".
-
-
-rlp_fail() ->
-    Temp     = temp_dir(),
-    TestFile = filename:join(Temp, "rlp_fail.test"),
-    ok       = filelib:ensure_dir(TestFile),
-    Data     = [<<"item1">>, <<"item2">>],
-    FullRLP  = gmser_rlp:encode(Data),
-    TruncRLP = binary:part(FullRLP, 0, byte_size(FullRLP) - 2),
-    ok       = file:write_file(TestFile, TruncRLP),
-    Run      = "bin/run rlp_fail " ++ Temp,
-    Out      = trim(os:cmd(Run)),
-    string:prefix(Out, "RLP_EXCEPTION:") =/= nomatch.
-
-
-gaju_format() ->
-    Temp = temp_dir(),
-    TestFile = filename:join(Temp, "gaju_format.test"),
-    ok = filelib:ensure_dir(TestFile),
-    Cases = [gen_case() || _ <- lists:seq(1, 100)],
-    Lines = [serialize_case(C) || C <- Cases],
-    ok = file:write_file(TestFile, unicode:characters_to_binary([[L, "\n"] || L <- Lines])),
-    Run = "bin/run gaju_format " ++ Temp,
-    RawOut = os:cmd(Run),
-    JavaResPath = trim(RawOut),
-    case file:read_file(JavaResPath) of
-        {ok, ResContent} ->
-            JavaResults = string:split(trim(unicode:characters_to_list(ResContent)), "\n", all),
-            length(Cases) =:= length(JavaResults) andalso compare_results(Cases, JavaResults);
-        {error, Reason} ->
-            Format = "Failed to read Java results from: ~tp (Reason: ~tp)~nRaw Output: ~ts~n",
-            io:format(Format, [JavaResPath, Reason, RawOut]),
-            false
-    end.
-
-
-
-%%% Generatorators
-
-gen_case() ->
-    Ops = [amount, approx, read],
-    Op = lists:nth(rand:uniform(length(Ops)), Ops),
-    gen_case(Op).
-
-gen_case(read) ->
-    Pucks = random_pucks(12),
-    Style = random_style(),
-    {read, hz_format:amount(gaju, Style, Pucks), Pucks};
-gen_case(amount) ->
-    Unit = random_unit(),
-    Pucks =
-        case Unit of
-            gaju -> random_pucks(12);
-            puck -> random_pucks(8)
-        end,
-    Style = random_style(),
-    Sep = lists:nth(rand:uniform(2), [$,, $_]),
-    Span = rand:uniform(4),
-    Amount = hz_format:amount(Unit, hz_style(Style, Sep, Span), Pucks),
-    {amount, Style, Unit, Sep, Span, Pucks, Amount};
-gen_case(approx) ->
-    Pucks = random_pucks(12),
-    Sep = lists:nth(rand:uniform(2), [$,, $_]),
-    Span = rand:uniform(2) + 2,
-    Prec = rand:uniform(18),
-    Approx = hz_format:approx_amount({Sep, Span}, Prec, Pucks),
-    {approx, us, gaju, Sep, Span, Pucks, Prec, Approx}.
-
-random_pucks(MaxBytes) ->
-    Bytes = rand:bytes(rand:uniform(MaxBytes)),
-    crypto:bytes_to_integer(Bytes).
-
-random_style() ->
-    lists:nth(rand:uniform(4), [us, jp, metric, legacy]).
-
-random_unit() ->
-    lists:nth(rand:uniform(2), [gaju, puck]).
-
-hz_style(us, Sep, Span) -> {Sep, Span};
-hz_style(Style, _, _)   -> Style.
-
-serialize_case({amount, Style, Unit, Sep, Span, Pucks, _}) ->
-    FStyle = string:uppercase(atom_to_list(Style)),
-    FUnit = string:uppercase(atom_to_list(Unit)),
-    Stuff = [FStyle, FUnit, Sep, Span, Pucks],
-    io_lib:format("amount|~ts|~ts|~c|~b|~b", Stuff);
-serialize_case({approx, Style, Unit, Sep, Span, Pucks, Prec, _}) ->
-    FStyle = string:uppercase(atom_to_list(Style)),
-    FUnit = string:uppercase(atom_to_list(Unit)),
-    Stuff = [FStyle, FUnit, Sep, Span, Pucks, Prec],
-    io_lib:format("approx|~ts|~ts|~c|~b|~b|~b", Stuff);
-serialize_case({read, Input, _}) ->
-    InputStr = unicode:characters_to_list(Input),
-    io_lib:format("read|~ts", [InputStr]).
-
-compare_results([], []) ->
-    true;
-compare_results([Case | Cases], [Result | Results]) ->
-    case check_case(Case, Result) of
-        true ->
-            compare_results(Cases, Results);
-        false ->
-            io:format("Parity failure!~nCase: ~tp~nJava Result: ~tp~n", [Case, Result]),
-            false
-    end.
-
-check_case({amount, _, _, _, _, _, Expected}, Result) ->
-    flatten(Expected) =:= flatten(Result);
-check_case({approx, _, _, _, _, _, _, Expected}, Result) ->
-    flatten(Expected) =:= flatten(Result);
-check_case({read, _, Expected}, Result) ->
-    integer_to_list(Expected) =:= flatten(Result).
-
-flatten(B) when is_binary(B) -> unicode:characters_to_list(B);
-flatten(L) when is_list(L)   -> unicode:characters_to_list(L).
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free 
+ *    Software Foundation, either version 3 of the License, or (at your option) 
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the 
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must 
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.crypto;
+
+import java.util.Arrays;
+import swiss.qpq.gajumaru.core.tools.CryptoUtils;
+
+
+// Pure Java implementation of BLAKE2b.
+// Based on eblake2.erl.
+
+public final class Blake2b {
+
+    private static final long[] IV = {
+        0x6a09e667f3bcc908L, 0xbb67ae8584caa73bL, 0x3c6ef372fe94f82bL, 0xa54ff53a5f1d36f1L,
+        0x510e527fade682d1L, 0x9b05688c2b3e6c1fL, 0x1f83d9abfb41bd6bL, 0x5be0cd19137e2179L
+    };
+
+    private static final byte[][] SIGMA = {
+        {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
+        { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 },
+        { 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 },
+        {  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 },
+        {  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 },
+        {  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 },
+        { 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 },
+        { 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 },
+        {  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 },
+        { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13,  0 },
+        {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 }, // Round 10: sigma[0]
+        { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 }  // Round 11: sigma[1]
+    };
+
+    private Blake2b() {}
+
+    public static byte[] hash(byte[] data) {
+        return hash(data, 32);
+    }
+
+    public static byte[] hash(byte[] data, int hashLen) {
+        long[] h = Arrays.copyOf(IV, 8);
+        h[0] ^= 0x01010000L ^ hashLen;
+
+        long t0 = 0;
+        long t1 = 0;
+        
+        int offset = 0;
+        while (offset + 128 < data.length) {
+            t0 += 128;
+            if (t0 < 128) t1++; // Overflow
+            compress(h, data, offset, t0, t1, false);
+            offset += 128;
+        }
+
+        t0 += (data.length - offset);
+        if (t0 < (data.length - offset)) t1++;
+        
+        byte[] lastBlock = new byte[128];
+        System.arraycopy(data, offset, lastBlock, 0, data.length - offset);
+        compress(h, lastBlock, 0, t0, t1, true);
+
+        byte[] fullHash = new byte[64];
+        for (int i = 0; i < 8; i++) {
+            writeLongLittleEndian(h[i], fullHash, i * 8);
+        }
+
+        byte[] result = Arrays.copyOf(fullHash, hashLen);
+        
+        // Memory hygiene
+        Arrays.fill(h, 0L);
+        Arrays.fill(fullHash, (byte) 0);
+        Arrays.fill(lastBlock, (byte) 0);
+        
+        return result;
+    }
+
+    private static void compress(long[] h, byte[] block, int offset, long t0, long t1, boolean isLast) {
+        long[] m = new long[16];
+        for (int i = 0; i < 16; i++) {
+            m[i] = readLongLittleEndian(block, offset + i * 8);
+        }
+
+        long[] v = new long[16];
+        System.arraycopy( h, 0, v, 0, 8);
+        System.arraycopy(IV, 0, v, 8, 8);
+
+        v[12] ^= t0;
+        v[13] ^= t1;
+        if (isLast) {
+            v[14] ^= 0xffffffffffffffffL;
+        }
+
+        for (int round = 0; round < 12; round++) {
+            byte[] s = SIGMA[round];
+            g(v, 0, 4,  8, 12, m[s[0]],  m[s[1]]);
+            g(v, 1, 5,  9, 13, m[s[2]],  m[s[3]]);
+            g(v, 2, 6, 10, 14, m[s[4]],  m[s[5]]);
+            g(v, 3, 7, 11, 15, m[s[6]],  m[s[7]]);
+            g(v, 0, 5, 10, 15, m[s[8]],  m[s[9]]);
+            g(v, 1, 6, 11, 12, m[s[10]], m[s[11]]);
+            g(v, 2, 7,  8, 13, m[s[12]], m[s[13]]);
+            g(v, 3, 4,  9, 14, m[s[14]], m[s[15]]);
+        }
+
+        for (int i = 0; i < 8; i++) {
+            h[i] ^= v[i] ^ v[i + 8];
+        }
+        
+        // Wiping local arrays
+        Arrays.fill(m, 0L);
+        Arrays.fill(v, 0L);
+    }
+
+    private static void g(long[] v, int a, int b, int c, int d, long x, long y) {
+        v[a] = v[a] + v[b] + x;
+        v[d] = Long.rotateRight(v[d] ^ v[a], 32);
+        v[c] = v[c] + v[d];
+        v[b] = Long.rotateRight(v[b] ^ v[c], 24);
+        v[a] = v[a] + v[b] + y;
+        v[d] = Long.rotateRight(v[d] ^ v[a], 16);
+        v[c] = v[c] + v[d];
+        v[b] = Long.rotateRight(v[b] ^ v[c], 63);
+    }
+
+    private static long readLongLittleEndian(byte[] b, int offset) {
+        long res = 0;
+        for (int i = 0; i < 8; i++) {
+            res |= ((long) (b[offset + i] & 0xFF)) << (i * 8);
+        }
+        return res;
+    }
+
+    private static void writeLongLittleEndian(long v, byte[] b, int offset) {
+        for (int i = 0; i < 8; i++) {
+            b[offset + i] = (byte) ((v >>> (i * 8)) & 0xFF);
+        }
+    }
+}
@@ -0,0 +1,849 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free
+ *    Software Foundation, either version 3 of the License, or (at your option)
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.crypto;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+import swiss.qpq.gajumaru.core.tools.CryptoUtils;
+
+
+// Pure Java implementation of Ed25519 curve arithmetic.
+// Uses high-performance Radix-2^25.5 field arithmetic.
+// Verified against the canonical Erlang ec_utils.
+
+public final class Ed25519 {
+
+    // Precomputed limbs for Ed25519 constants (Radix 2^25.5)
+    private static final long[] BX = {52811034L, 25909283L, 16144682L, 17082669L, 27570973L, 30858332L, 40966398L,  8378388L, 20764389L,  8758491L};
+    private static final long[] BY = {40265304L, 26843545L, 13421772L, 20132659L, 26843545L,  6710886L, 53687091L, 13421772L, 40265318L, 26843545L};
+    private static final long[] D  = {56195235L, 13857412L, 51736253L,  6949390L,   114729L, 24766616L, 60832955L, 30306712L, 48412415L, 21499315L};
+    private static final long[] D2 = {45281625L, 27714825L, 36363642L, 13898781L,   229458L, 15978800L, 54557047L, 27058993L, 29715967L,  9444199L};
+    private static final long[] I  = {34513072L, 25610706L,  9377949L,  3500415L, 12389472L, 33281959L, 41962654L, 31548777L,   326685L, 11406482L};
+
+    public static final class Ge {
+        public final long[] X = new long[10], Y = new long[10], Z = new long[10], T = new long[10];
+
+        public void wipe() {
+            CryptoUtils.wipe(X);
+            CryptoUtils.wipe(Y);
+            CryptoUtils.wipe(Z);
+            CryptoUtils.wipe(T);
+        }
+    }
+
+    public static final class Scratch {
+        public final long[]
+                a = new long[10], b = new long[10], c = new long[10], d = new long[10],
+                e = new long[10], f = new long[10], g = new long[10], h = new long[10],
+                tmp = new long[10], t19 = new long[19];
+        public final long[][] stack = new long[10][10];
+        public final Ge geTmp = new Ge();
+
+        public void wipe() {
+            CryptoUtils.wipe(a);
+            CryptoUtils.wipe(b);
+            CryptoUtils.wipe(c);
+            CryptoUtils.wipe(d);
+            CryptoUtils.wipe(e);
+            CryptoUtils.wipe(f);
+            CryptoUtils.wipe(g);
+            CryptoUtils.wipe(h);
+            CryptoUtils.wipe(tmp);
+            CryptoUtils.wipe(t19);
+            for (long[] s : stack) CryptoUtils.wipe(s);
+            geTmp.wipe();
+        }
+    }
+
+    private Ed25519() {
+    }
+
+    public static byte[] publicKey(byte[] seed) {
+        byte[] hash = sha512(seed);
+        byte[] s = Arrays.copyOfRange(hash, 0, 32);
+        s[0]  &= 248;
+        s[31] &= 127;
+        s[31] |=  64;
+        Scratch sc = new Scratch();
+        Ge A_point = scalarMulBase(s, sc);
+        byte[] A = compress(A_point, sc);
+        A_point.wipe();
+        sc.wipe();
+        CryptoUtils.wipe(hash);
+        CryptoUtils.wipe(s);
+        return A;
+    }
+
+    public static byte[] sign(byte[] seed, byte[] message) {
+        byte[] hash = sha512(seed);
+        byte[] s = Arrays.copyOfRange(hash, 0, 32);
+        s[0]  &= 248;
+        s[31] &= 127;
+        s[31] |=  64;
+        byte[] prefix = Arrays.copyOfRange(hash, 32, 64);
+        byte[] rHash = sha512(prefix, message);
+        reduceScalar(rHash);
+        byte[] r = Arrays.copyOfRange(rHash, 0, 32);
+        Scratch sc = new Scratch();
+        Ge R_point = scalarMulBase(r, sc);
+        byte[] R = compress(R_point, sc);
+        byte[] A = publicKey(seed);
+        byte[] kHash = sha512(R, A, message);
+        reduceScalar(kHash);
+        byte[] k = Arrays.copyOfRange(kHash, 0, 32);
+        byte[] S = new byte[32];
+        scalarMulAdd(S, k, s, r);
+        byte[] sig = new byte[64];
+        System.arraycopy(R, 0, sig, 0, 32);
+        System.arraycopy(S, 0, sig, 32, 32);
+        R_point.wipe();
+        sc.wipe();
+        CryptoUtils.wipe(hash);
+        CryptoUtils.wipe(s);
+        CryptoUtils.wipe(prefix);
+        CryptoUtils.wipe(rHash);
+        CryptoUtils.wipe(r);
+        CryptoUtils.wipe(kHash);
+        CryptoUtils.wipe(k);
+        CryptoUtils.wipe(A);
+        return sig;
+    }
+
+    public static boolean verify(byte[] publicKey, byte[] message, byte[] signature) {
+        if (signature.length != 64) return false;
+        byte[] R_bytes = Arrays.copyOfRange(signature, 0, 32);
+        byte[] S_bytes = Arrays.copyOfRange(signature, 32, 64);
+        if ((S_bytes[31] & 0xe0) != 0) return false;
+        Scratch sc = new Scratch();
+        Ge A = decompress(publicKey, sc);
+        if (A == null) return false;
+        Ge R = decompress(R_bytes, sc);
+        if (R == null) return false;
+
+        byte[] kHash = sha512(R_bytes, publicKey, message);
+        reduceScalar(kHash);
+        byte[] k = Arrays.copyOfRange(kHash, 0, 32);
+
+        Ge sB = scalarMulBase(S_bytes, sc);
+        Ge kA = scalarMul(A, k, sc);
+        Ge RHS = new Ge();
+        ge_add(RHS, R, kA, sc);
+
+        byte[] LHS_bytes = compress(sB, sc);
+        byte[] RHS_bytes = compress(RHS, sc);
+
+        boolean ok = Arrays.equals(LHS_bytes, RHS_bytes);
+
+        A.wipe();
+        R.wipe();
+        sB.wipe();
+        kA.wipe();
+        RHS.wipe();
+        sc.wipe();
+        CryptoUtils.wipe(kHash);
+        CryptoUtils.wipe(k);
+        return ok;
+    }
+
+    public static Ge scalarMulBase(byte[] scalar, Scratch s) {
+        Ge res = new Ge();
+        fe_0(res.X);
+        fe_1(res.Y);
+        fe_1(res.Z);
+        fe_0(res.T);
+        Ge q = new Ge();
+        fe_copy(q.X, BX);
+        fe_copy(q.Y, BY);
+        fe_1(q.Z);
+        fe_mul(q.T, BX, BY, s.t19);
+        for (int i = 0; i < 256; i++) {
+            int bit = ((scalar[i / 8] & 0xFF) >>> (i % 8)) & 1;
+            ge_add(s.geTmp, res, q, s);
+            ge_cmov(res, s.geTmp, bit);
+            ge_double(q, q, s);
+        }
+        q.wipe();
+        return res;
+    }
+
+    public static void ge_double_scalarmul_vartime(Ge r, byte[] s, Ge a, byte[] k, Scratch sc) {
+        Ge sB = scalarMulBase(s, sc);
+        Ge kA = scalarMul(a, k, sc);
+        fe_neg(kA.X, kA.X);
+        fe_neg(kA.T, kA.T);
+        ge_add(r, sB, kA, sc);
+        sB.wipe();
+        kA.wipe();
+    }
+
+    public static Ge scalarMul(Ge p, byte[] scalar, Scratch s) {
+        Ge res = new Ge();
+        fe_0(res.X);
+        fe_1(res.Y);
+        fe_1(res.Z);
+        fe_0(res.T);
+        Ge q = new Ge();
+        fe_copy(q.X, p.X);
+        fe_copy(q.Y, p.Y);
+        fe_copy(q.Z, p.Z);
+        fe_copy(q.T, p.T);
+        for (int i = 0; i < 256; i++) {
+            int bit = ((scalar[i / 8] & 0xFF) >>> (i % 8)) & 1;
+            ge_add(s.geTmp, res, q, s);
+            ge_cmov(res, s.geTmp, bit);
+            ge_double(q, q, s);
+        }
+        q.wipe();
+        return res;
+    }
+
+    public static void ge_add(Ge r, Ge p1, Ge p2, Scratch s) {
+        long[] yMinusX1 = s.stack[0], yPlusX1 = s.stack[1], yMinusX2 = s.stack[2], yPlusX2 = s.stack[3];
+        long[] A = s.stack[4], B = s.stack[5], C = s.stack[6], D = s.stack[7];
+        long[] E = s.stack[8], F = s.stack[9], G = s.a, H = s.b;
+        fe_sub(yMinusX1, p1.Y, p1.X);
+        fe_add(yPlusX1, p1.Y, p1.X);
+        fe_sub(yMinusX2, p2.Y, p2.X);
+        fe_add(yPlusX2, p2.Y, p2.X);
+        fe_mul(A, yMinusX1, yMinusX2, s.t19);
+        fe_mul(B, yPlusX1, yPlusX2, s.t19);
+        fe_mul(C, p1.T, p2.T, s.t19);
+        fe_mul(C, C, D2, s.t19);
+        fe_mul(D, p1.Z, p2.Z, s.t19);
+        fe_add(D, D, D);
+        fe_sub(E, B, A);
+        fe_sub(F, D, C);
+        fe_add(G, D, C);
+        fe_add(H, B, A);
+        fe_mul(r.X, E, F, s.t19);
+        fe_mul(r.Y, G, H, s.t19);
+        fe_mul(r.Z, F, G, s.t19);
+        fe_mul(r.T, E, H, s.t19);
+    }
+
+    public static void ge_double(Ge r, Ge p, Scratch s) {
+        long[] A = s.stack[0], B = s.stack[1], C = s.stack[2], D = s.stack[3];
+        long[] E = s.stack[4], F = s.stack[5], G = s.stack[6], H = s.stack[7];
+        fe_sq(A, p.X, s.t19);
+        fe_sq(B, p.Y, s.t19);
+        fe_sq(C, p.Z, s.t19);
+        fe_add(C, C, C);
+        fe_neg(D, A);
+        fe_add(E, p.X, p.Y);
+        fe_sq(E, E, s.t19);
+        fe_sub(E, E, A);
+        fe_sub(E, E, B);
+        fe_add(G, D, B);
+        fe_sub(F, G, C);
+        fe_sub(H, D, B);
+        fe_mul(r.X, E, F, s.t19);
+        fe_mul(r.Y, G, H, s.t19);
+        fe_mul(r.Z, F, G, s.t19);
+        fe_mul(r.T, E, H, s.t19);
+    }
+
+    private static void ge_cmov(Ge r, Ge p, int b) {
+        fe_cmov(r.X, p.X, b);
+        fe_cmov(r.Y, p.Y, b);
+        fe_cmov(r.Z, p.Z, b);
+        fe_cmov(r.T, p.T, b);
+    }
+
+    private static void fe_cmov(long[] r, long[] p, int b) {
+        long mask = -(long) b;
+        for (int i = 0; i < 10; i++) {
+            long x = mask & (r[i] ^ p[i]);
+            r[i] ^= x;
+        }
+    }
+
+    public static Ge decompress(byte[] b, Scratch s) {
+        if (b.length != 32) return null;
+        Ge p = new Ge();
+        fe_frombytes(p.Y, b);
+        fe_1(p.Z);
+
+        // u = y^2 - 1
+        fe_sq(s.a, p.Y, s.t19);
+        fe_sub(s.a, s.a, p.Z);
+
+        // v = dy^2 + 1
+        fe_sq(s.b, p.Y, s.t19);
+        fe_mul(s.b, s.b, D, s.t19);
+        fe_add(s.b, s.b, p.Z);
+
+        // check root of u/v
+        fe_invert(s.c, s.b, s);
+        fe_mul(s.c, s.a, s.c, s.t19); // x2 = u/v
+
+        fe_pow22523(s.a, s.c, s);    // a = x2^((p-5)/8)
+        fe_mul(s.a, s.c, s.a, s.t19); // x = x2 * a = x2^((p+3)/8)
+
+        fe_sq(s.b, s.a, s.t19);
+        fe_sub(s.b, s.b, s.c);       // x^2 - x2
+        if (fe_isnonzero(s.b)) {
+            fe_mul(s.a, s.a, I, s.t19);
+            fe_sq(s.b, s.a, s.t19);
+            fe_sub(s.b, s.b, s.c);
+            if (fe_isnonzero(s.b)) return null;
+        }
+
+        if (fe_isnegative(s.a) != ((b[31] >> 7) & 1)) fe_neg(p.X, s.a);
+        else fe_copy(p.X, s.a);
+
+        fe_mul(p.T, p.X, p.Y, s.t19);
+        return p;
+    }
+
+    public static byte[] compress(Ge p, Scratch s) {
+        fe_invert(s.a, p.Z, s);
+        fe_mul(s.b, p.X, s.a, s.t19);
+        fe_mul(s.c, p.Y, s.a, s.t19);
+        byte[] out = fe_contract(s.c);
+        if (fe_isnegative(s.b) == 1) out[31] |= (byte) 0x80;
+        return out;
+    }
+
+    private static void fe_0(long[] h) {
+        for (int i = 0; i < 10; i++) h[i] = 0;
+    }
+
+    private static void fe_1(long[] h) {
+        h[0] = 1;
+        for (int i = 1; i < 10; i++) h[i] = 0;
+    }
+
+    private static void fe_copy(long[] h, long[] f) {
+        System.arraycopy(f, 0, h, 0, 10);
+    }
+
+    private static void fe_add(long[] h, long[] f, long[] g) {
+        for (int i = 0; i < 10; i++) h[i] = f[i] + g[i];
+    }
+
+    private static void fe_sub(long[] h, long[] f, long[] g) {
+        for (int i = 0; i < 10; i++) h[i] = f[i] - g[i];
+    }
+
+    private static void fe_neg(long[] h, long[] f) {
+        for (int i = 0; i < 10; i++) h[i] = -f[i];
+    }
+
+    public static void fe_mul(long[] out, long[] f, long[] g, long[] t) {
+        t[0] = f[0] * g[0];
+        t[1] = f[0] * g[1] + f[1] * g[0];
+        t[2] = f[0] * g[2] + f[2] * g[0] + 2 * f[1] * g[1];
+        t[3] = f[0] * g[3] + f[3] * g[0] + f[1] * g[2] + f[2] * g[1];
+        t[4] = f[0] * g[4] + f[4] * g[0] + f[2] * g[2] + 2 * f[1] * g[3] + 2 * f[3] * g[1];
+        t[5] = f[0] * g[5] + f[5] * g[0] + f[1] * g[4] + f[4] * g[1] + f[2] * g[3] + f[3] * g[2];
+        t[6] = f[0] * g[6] + f[6] * g[0] + f[2] * g[4] + f[4] * g[2] + 2 * f[1] * g[5] + 2 * f[5] * g[1] + 2 * f[3] * g[3];
+        t[7] = f[0] * g[7] + f[7] * g[0] + f[1] * g[6] + f[6] * g[1] + f[2] * g[5] + f[5] * g[2] + f[3] * g[4] + f[4] * g[3];
+        t[8] = f[0] * g[8] + f[8] * g[0] + f[2] * g[6] + f[6] * g[2] + f[4] * g[4] + 2 * f[1] * g[7] + 2 * f[7] * g[1] + 2 * f[3] * g[5] + 2 * f[5] * g[3];
+        t[9] = f[0] * g[9] + f[9] * g[0] + f[1] * g[8] + f[8] * g[1] + f[2] * g[7] + f[7] * g[2] + f[3] * g[6] + f[6] * g[3] + f[4] * g[5] + f[5] * g[4];
+        t[10] = 2 * f[1] * g[9] + 2 * f[9] * g[1] + f[2] * g[8] + f[8] * g[2] + 2 * f[3] * g[7] + 2 * f[7] * g[3] + f[4] * g[6] + f[6] * g[4] + 2 * f[5] * g[5];
+        t[11] = f[2] * g[9] + f[9] * g[2] + f[3] * g[8] + f[8] * g[3] + f[4] * g[7] + f[7] * g[4] + f[5] * g[6] + f[6] * g[5];
+        t[12] = 2 * f[3] * g[9] + 2 * f[9] * g[3] + f[4] * g[8] + f[8] * g[4] + 2 * f[5] * g[7] + 2 * f[7] * g[5] + f[6] * g[6];
+        t[13] = f[4] * g[9] + f[9] * g[4] + f[5] * g[8] + f[8] * g[5] + f[6] * g[7] + f[7] * g[6];
+        t[14] = 2 * f[5] * g[9] + 2 * f[9] * g[5] + f[6] * g[8] + f[8] * g[6] + 2 * f[7] * g[7];
+        t[15] = f[6] * g[9] + f[9] * g[6] + f[7] * g[8] + f[8] * g[7];
+        t[16] = 2 * f[7] * g[9] + 2 * f[9] * g[7] + f[8] * g[8];
+        t[17] = f[8] * g[9] + f[9] * g[8];
+        t[18] = 2 * f[9] * g[9];
+        fe_reduce(out, t);
+    }
+
+    public static void fe_sq(long[] out, long[] f, long[] t) {
+        t[0] = f[0] * f[0];
+        t[1] = 2 * f[0] * f[1];
+        t[2] = 2 * f[0] * f[2] + 2 * f[1] * f[1];
+        t[3] = 2 * f[0] * f[3] + 2 * f[1] * f[2];
+        t[4] = 2 * f[0] * f[4] + 4 * f[1] * f[3] + f[2] * f[2];
+        t[5] = 2 * f[0] * f[5] + 2 * f[1] * f[4] + 2 * f[2] * f[3];
+        t[6] = 2 * f[0] * f[6] + 4 * f[1] * f[5] + 2 * f[2] * f[4] + 2 * f[3] * f[3];
+        t[7] = 2 * f[0] * f[7] + 2 * f[1] * f[6] + 2 * f[2] * f[5] + 2 * f[3] * f[4];
+        t[8] = 2 * f[0] * f[8] + 4 * f[1] * f[7] + 2 * f[2] * f[6] + 4 * f[3] * f[5] + f[4] * f[4];
+        t[9] = 2 * f[0] * f[9] + 2 * f[1] * f[8] + 2 * f[2] * f[7] + 2 * f[3] * f[6] + 2 * f[4] * f[5];
+        t[10] = 4 * f[1] * f[9] + 2 * f[2] * f[8] + 4 * f[3] * f[7] + 2 * f[4] * f[6] + 2 * f[5] * f[5];
+        t[11] = 2 * f[2] * f[9] + 2 * f[3] * f[8] + 2 * f[4] * f[7] + 2 * f[5] * f[6];
+        t[12] = 4 * f[3] * f[9] + 2 * f[4] * f[8] + 4 * f[5] * f[7] + f[6] * f[6];
+        t[13] = 2 * f[4] * f[9] + 2 * f[5] * f[8] + 2 * f[6] * f[7];
+        t[14] = 4 * f[5] * f[9] + 2 * f[6] * f[8] + 2 * f[7] * f[7];
+        t[15] = 2 * f[6] * f[9] + 2 * f[7] * f[8];
+        t[16] = 4 * f[7] * f[9] + f[8] * f[8];
+        t[17] = 2 * f[8] * f[9];
+        t[18] = 2 * f[9] * f[9];
+        fe_reduce(out, t);
+    }
+
+    public static void fe_reduce(long[] h, long[] t) {
+        t[0] += t[10] * 19;
+        t[1] += t[11] * 19;
+        t[2] += t[12] * 19;
+        t[3] += t[13] * 19;
+        t[4] += t[14] * 19;
+        t[5] += t[15] * 19;
+        t[6] += t[16] * 19;
+        t[7] += t[17] * 19;
+        t[8] += t[18] * 19;
+        for (int p = 0; p < 2; p++) {
+            for (int i = 0; i < 9; i++) {
+                long c = t[i] >> (i % 2 == 0 ? 26 : 25);
+                t[i] &= (i % 2 == 0 ? 0x3FFFFFFL : 0x1FFFFFFL);
+                t[i + 1] += c;
+            }
+            long c = t[9] >> 25;
+            t[9] &= 0x1FFFFFFL;
+            t[0] += c * 19;
+        }
+        for (int i = 0; i < 10; i++) h[i] = t[i];
+    }
+
+    public static void fe_frombytes(long[] h, byte[] s) {
+        for (int i = 0; i < 10; i++) h[i] = 0;
+        int bitIdx = 0;
+        for (int i = 0; i < 10; i++) {
+            int len = (i % 2 == 0 ? 26 : 25);
+            for (int b = 0; b < len; b++) {
+                if (bitIdx < 255) {
+                    if ((((s[bitIdx / 8] & 0xFF) >> (bitIdx % 8)) & 1) == 1) h[i] |= (1L << b);
+                }
+                bitIdx++;
+            }
+        }
+    }
+
+    public static byte[] fe_contract(long[] h) {
+        long[] val = Arrays.copyOf(h, 10);
+        for (int p = 0; p < 2; p++) {
+            for (int i = 0; i < 9; i++) {
+                long c = val[i] >> (i % 2 == 0 ? 26 : 25);
+                val[i] &= (i % 2 == 0 ? 0x3FFFFFFL : 0x1FFFFFFL);
+                val[i + 1] += c;
+            }
+            long c = val[9] >> 25;
+            val[9] &= 0x1FFFFFFL;
+            val[0] += c * 19;
+        }
+        long mask = 1;
+        for (int i = 9; i >= 0; i--) {
+            long target = (i % 2 == 0 ? 0x3FFFFFFL : 0x1FFFFFFL);
+            if (i == 0) target -= 19;
+            if (val[i] < target) {
+                mask = 0;
+                break;
+            }
+            if (val[i] > target) break;
+        }
+        val[0] += mask * 19;
+        for (int i = 0; i < 9; i++) {
+            long c = val[i] >> (i % 2 == 0 ? 26 : 25);
+            val[i] &= (i % 2 == 0 ? 0x3FFFFFFL : 0x1FFFFFFL);
+            val[i + 1] += c;
+        }
+        val[9] -= mask * (1L << 25);
+        for (int i = 0; i < 9; i++) {
+            long c = val[i] >> (i % 2 == 0 ? 26 : 25);
+            val[i] &= (i % 2 == 0 ? 0x3FFFFFFL : 0x1FFFFFFL);
+            val[i + 1] += c;
+        }
+        val[0] += (val[9] >> 25) * 19;
+        val[9] &= 0x1FFFFFFL;
+        byte[] out = new byte[32];
+        int bitIdx = 0;
+        for (int i = 0; i < 10; i++) {
+            int len = (i % 2 == 0 ? 26 : 25);
+            for (int bit = 0; bit < len; bit++) {
+                if (bitIdx < 255) {
+                    if (((val[i] >> bit) & 1) == 1) out[bitIdx / 8] |= (byte) (1 << (bitIdx % 8));
+                    bitIdx++;
+                }
+            }
+        }
+        return out;
+    }
+
+    private static void fe_invert(long[] out, long[] z, Scratch s) {
+        long[] t0 = s.stack[0], t1 = s.stack[1], z2 = s.stack[2], z9 = s.stack[3], z11 = s.stack[4];
+        long[] z2_5_0 = s.stack[5], z2_10_0 = s.stack[6], z2_20_0 = s.stack[7], z2_50_0 = s.stack[8], z2_100_0 = s.stack[9];
+        fe_sq(z2, z, s.t19);
+        fe_sq(t1, z2, s.t19);
+        fe_sq(t0, t1, s.t19);
+        fe_mul(z9, t0, z, s.t19);
+        fe_mul(z11, z9, z2, s.t19);
+        fe_sq(t0, z11, s.t19);
+        fe_mul(z2_5_0, t0, z9, s.t19);
+        fe_sq(t0, z2_5_0, s.t19);
+        for (int i = 1; i < 5; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_10_0, t0, z2_5_0, s.t19);
+        fe_sq(t0, z2_10_0, s.t19);
+        for (int i = 1; i < 10; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_20_0, t0, z2_10_0, s.t19);
+        fe_sq(t0, z2_20_0, s.t19);
+        for (int i = 1; i < 20; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(t0, t0, z2_20_0, s.t19);
+        fe_sq(t0, t0, s.t19);
+        for (int i = 1; i < 10; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_50_0, t0, z2_10_0, s.t19);
+        fe_sq(t0, z2_50_0, s.t19);
+        for (int i = 1; i < 50; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_100_0, t0, z2_50_0, s.t19);
+        fe_sq(t1, z2_100_0, s.t19);
+        for (int i = 1; i < 100; i++) fe_sq(t1, t1, s.t19);
+        fe_mul(t1, t1, z2_100_0, s.t19);
+        fe_sq(t0, t1, s.t19);
+        for (int i = 1; i < 50; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(t0, t0, z2_50_0, s.t19);
+        fe_sq(t1, t0, s.t19);
+        for (int i = 1; i < 5; i++) fe_sq(t1, t1, s.t19);
+        fe_mul(out, t1, z11, s.t19);
+    }
+
+    private static void fe_pow22523(long[] out, long[] in, Scratch s) {
+        long[] t0 = s.stack[0], t1 = s.stack[1], z2 = s.stack[2], z9 = s.stack[3], z11 = s.stack[4];
+        long[] z2_5_0 = s.stack[5], z2_10_0 = s.stack[6], z2_20_0 = s.stack[7], z2_50_0 = s.stack[8], z2_100_0 = s.stack[9];
+        fe_sq(z2, in, s.t19);
+        fe_sq(t1, z2, s.t19);
+        fe_sq(t0, t1, s.t19);
+        fe_mul(z9, t0, in, s.t19);
+        fe_mul(z11, z9, z2, s.t19);
+        fe_sq(t0, z11, s.t19);
+        fe_mul(z2_5_0, t0, z9, s.t19);
+        fe_sq(t0, z2_5_0, s.t19);
+        for (int i = 1; i < 5; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_10_0, t0, z2_5_0, s.t19);
+        fe_sq(t0, z2_10_0, s.t19);
+        for (int i = 1; i < 10; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_20_0, t0, z2_10_0, s.t19);
+        fe_sq(t0, z2_20_0, s.t19);
+        for (int i = 1; i < 20; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(t0, t0, z2_20_0, s.t19);
+        fe_sq(t0, t0, s.t19);
+        for (int i = 1; i < 10; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_50_0, t0, z2_10_0, s.t19);
+        fe_sq(t0, z2_50_0, s.t19);
+        for (int i = 1; i < 50; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(z2_100_0, t0, z2_50_0, s.t19);
+        fe_sq(t1, z2_100_0, s.t19);
+        for (int i = 1; i < 100; i++) fe_sq(t1, t1, s.t19);
+        fe_mul(t1, t1, z2_100_0, s.t19);
+        fe_sq(t0, t1, s.t19);
+        for (int i = 1; i < 50; i++) fe_sq(t0, t0, s.t19);
+        fe_mul(t0, t0, z2_50_0, s.t19);
+        fe_sq(t0, t0, s.t19);
+        fe_sq(t0, t0, s.t19);
+        fe_mul(out, t0, in, s.t19);
+    }
+
+    private static boolean fe_isnonzero(long[] h) {
+        byte[] s = fe_contract(h);
+        for (byte b : s) if (b != 0) return true;
+        return false;
+    }
+
+    private static int fe_isnegative(long[] h) {
+        byte[] s = fe_contract(h);
+        return s[0] & 1;
+    }
+
+    public static void reduceScalar(byte[] s) {
+        long  s0 = 2097151 &  load3(s,  0);
+        long  s1 = 2097151 & (load4(s,  2) >> 5);
+        long  s2 = 2097151 & (load3(s,  5) >> 2);
+        long  s3 = 2097151 & (load4(s,  7) >> 7);
+        long  s4 = 2097151 & (load4(s, 10) >> 4);
+        long  s5 = 2097151 & (load3(s, 13) >> 1);
+        long  s6 = 2097151 & (load4(s, 15) >> 6);
+        long  s7 = 2097151 & (load3(s, 18) >> 3);
+        long  s8 = 2097151 & load3(s,  21);
+        long  s9 = 2097151 & (load4(s, 23) >> 5);
+        long s10 = 2097151 & (load3(s, 26) >> 2);
+        long s11 = 2097151 & (load4(s, 28) >> 7);
+        long s12 = 2097151 & (load4(s, 31) >> 4);
+        long s13 = 2097151 & (load3(s, 34) >> 1);
+        long s14 = 2097151 & (load4(s, 36) >> 6);
+        long s15 = 2097151 & (load3(s, 39) >> 3);
+        long s16 = 2097151 & load3(s,  42);
+        long s17 = 2097151 & (load4(s, 44) >> 5);
+        long s18 = 2097151 & (load3(s, 47) >> 2);
+        long s19 = 2097151 & (load4(s, 49) >> 7);
+        long s20 = 2097151 & (load4(s, 52) >> 4);
+        long s21 = 2097151 & (load3(s, 55) >> 1);
+        long s22 = 2097151 & (load4(s, 57) >> 6);
+        long s23 = (load4(s, 60) >> 3);
+        s11 += s23 * 666643;
+        s12 += s23 * 470296;
+        s13 += s23 * 654183;
+        s14 -= s23 * 997805;
+        s15 += s23 * 136657;
+        s16 -= s23 * 683901;
+        s10 += s22 * 666643;
+        s11 += s22 * 470296;
+        s12 += s22 * 654183;
+        s13 -= s22 * 997805;
+        s14 += s22 * 136657;
+        s15 -= s22 * 683901;
+        s9  += s21 * 666643;
+        s10 += s21 * 470296;
+        s11 += s21 * 654183;
+        s12 -= s21 * 997805;
+        s13 += s21 * 136657;
+        s14 -= s21 * 683901;
+        s8  += s20 * 666643;
+        s9  += s20 * 470296;
+        s10 += s20 * 654183;
+        s11 -= s20 * 997805;
+        s12 += s20 * 136657;
+        s13 -= s20 * 683901;
+        s7  += s19 * 666643;
+        s8  += s19 * 470296;
+        s9  += s19 * 654183;
+        s10 -= s19 * 997805;
+        s11 += s19 * 136657;
+        s12 -= s19 * 683901;
+        s6  += s18 * 666643;
+        s7  += s18 * 470296;
+        s8  += s18 * 654183;
+        s9  -= s18 * 997805;
+        s10 += s18 * 136657;
+        s11 -= s18 * 683901;
+        long c6 = (s6 + (1 << 20)) >> 21;
+        s7 += c6;
+        s6 -= c6 << 21;
+        long c8 = (s8 + (1 << 20)) >> 21;
+        s9 += c8;
+        s8 -= c8 << 21;
+        long c10 = (s10 + (1 << 20)) >> 21;
+        s11 += c10;
+        s10 -= c10 << 21;
+        long c12 = (s12 + (1 << 20)) >> 21;
+        s13 += c12;
+        s12 -= c12 << 21;
+        long c14 = (s14 + (1 << 20)) >> 21;
+        s15 += c14;
+        s14 -= c14 << 21;
+        long c16 = (s16 + (1 << 20)) >> 21;
+        s17 += c16;
+        s16 -= c16 << 21;
+        long c7 = (s7 + (1 << 20)) >> 21;
+        s8 += c7;
+        s7 -= c7 << 21;
+        long c9 = (s9 + (1 << 20)) >> 21;
+        s10 += c9;
+        s9 -= c9 << 21;
+        long c11 = (s11 + (1 << 20)) >> 21;
+        s12 += c11;
+        s11 -= c11 << 21;
+        long c13 = (s13 + (1 << 20)) >> 21;
+        s14 += c13;
+        s13 -= c13 << 21;
+        long c15 = (s15 + (1 << 20)) >> 21;
+        s16 += c15;
+        s15 -= c15 << 21;
+        s5 += s17 * 666643;
+        s6 += s17 * 470296;
+        s7 += s17 * 654183;
+        s8 -= s17 * 997805;
+        s9 += s17 * 136657;
+        s10 -= s17 * 683901;
+        s4 += s16 * 666643;
+        s5 += s16 * 470296;
+        s6 += s16 * 654183;
+        s7 -= s16 * 997805;
+        s8 += s16 * 136657;
+        s9 -= s16 * 683901;
+        s3 += s15 * 666643;
+        s4 += s15 * 470296;
+        s5 += s15 * 654183;
+        s6 -= s15 * 997805;
+        s7 += s15 * 136657;
+        s8 -= s15 * 683901;
+        s2 += s14 * 666643;
+        s3 += s14 * 470296;
+        s4 += s14 * 654183;
+        s5 -= s14 * 997805;
+        s6 += s14 * 136657;
+        s7 -= s14 * 683901;
+        s1 += s13 * 666643;
+        s2 += s13 * 470296;
+        s3 += s13 * 654183;
+        s4 -= s13 * 997805;
+        s5 += s13 * 136657;
+        s6 -= s13 * 683901;
+        s0 += s12 * 666643;
+        s1 += s12 * 470296;
+        s2 += s12 * 654183;
+        s3 -= s12 * 997805;
+        s4 += s12 * 136657;
+        s5 -= s12 * 683901;
+        long cc0 = (s0 + (1 << 20)) >> 21;
+        s1 += cc0;
+        s0 -= cc0 << 21;
+        long cc2 = (s2 + (1 << 20)) >> 21;
+        s3 += cc2;
+        s2 -= cc2 << 21;
+        long cc4 = (s4 + (1 << 20)) >> 21;
+        s5 += cc4;
+        s4 -= cc4 << 21;
+        long cc6 = (s6 + (1 << 20)) >> 21;
+        s7 += cc6;
+        s6 -= cc6 << 21;
+        long cc8 = (s8 + (1 << 20)) >> 21;
+        s9 += cc8;
+        s8 -= cc8 << 21;
+        long cc10 = (s10 + (1 << 20)) >> 21;
+        s11 += cc10;
+        s10 -= cc10 << 21;
+        long cc1 = (s1 + (1 << 20)) >> 21;
+        s2 += cc1;
+        s1 -= cc1 << 21;
+        long cc3 = (s3 + (1 << 20)) >> 21;
+        s4 += cc3;
+        s3 -= cc3 << 21;
+        long cc5 = (s5 + (1 << 20)) >> 21;
+        s6 += cc5;
+        s5 -= cc5 << 21;
+        long cc7 = (s7 + (1 << 20)) >> 21;
+        s8 += cc7;
+        s7 -= cc7 << 21;
+        long cc9 = (s9 + (1 << 20)) >> 21;
+        s10 += cc9;
+        s9 -= cc9 << 21;
+        long cc11 = (s11 + (1 << 20)) >> 21;
+        long s12_2 = cc11;
+        s11 -= cc11 << 21;
+        s0 += s12_2 * 666643;
+        s1 += s12_2 * 470296;
+        s2 += s12_2 * 654183;
+        s3 -= s12_2 * 997805;
+        s4 += s12_2 * 136657;
+        s5 -= s12_2 * 683901;
+        long ccc0 = s0 >> 21;
+        s1 += ccc0;
+        s0 -= ccc0 << 21;
+        long ccc1 = s1 >> 21;
+        s2 += ccc1;
+        s1 -= ccc1 << 21;
+        long ccc2 = s2 >> 21;
+        s3 += ccc2;
+        s2 -= ccc2 << 21;
+        long ccc3 = s3 >> 21;
+        s4 += ccc3;
+        s3 -= ccc3 << 21;
+        long ccc4 = s4 >> 21;
+        s5 += ccc4;
+        s4 -= ccc4 << 21;
+        long ccc5 = s5 >> 21;
+        s6 += ccc5;
+        s5 -= ccc5 << 21;
+        long ccc6 = s6 >> 21;
+        s7 += ccc6;
+        s6 -= ccc6 << 21;
+        long ccc7 = s7 >> 21;
+        s8 += ccc7;
+        s7 -= ccc7 << 21;
+        long ccc8 = s8 >> 21;
+        s9 += ccc8;
+        s8 -= ccc8 << 21;
+        long ccc9 = s9 >> 21;
+        s10 += ccc9;
+        s9 -= ccc9 << 21;
+        long ccc10 = s10 >> 21;
+        s11 += ccc10;
+        s10 -= ccc10 << 21;
+        long ccc11 = s11 >> 21;
+        long s12_3 = ccc11;
+        s11 -= ccc11 << 21;
+        s0 += s12_3 * 666643;
+        s1 += s12_3 * 470296;
+        s2 += s12_3 * 654183;
+        s3 -= s12_3 * 997805;
+        s4 += s12_3 * 136657;
+        s5 -= s12_3 * 683901;
+        long sccc0 = s0 >> 21;
+        s1 += sccc0;
+        s0 -= sccc0 << 21;
+        long sccc1 = s1 >> 21;
+        s2 += sccc1;
+        s1 -= sccc1 << 21;
+        long sccc2 = s2 >> 21;
+        s3 += sccc2;
+        s2 -= sccc2 << 21;
+        long sccc3 = s3 >> 21;
+        s4 += sccc3;
+        s3 -= sccc3 << 21;
+        long sccc4 = s4 >> 21;
+        s5 += sccc4;
+        s4 -= sccc4 << 21;
+        long sccc5 = s5 >> 21;
+        s6 += sccc5;
+        s5 -= sccc5 << 21;
+        Arrays.fill(s, (byte) 0);
+        long[] resLimbs = {s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11};
+        int bitIdx = 0;
+        for (int limbIdx = 0; limbIdx < 12; limbIdx++) {
+            for (int i = 0; i < 21; i++) {
+                if (bitIdx < 256) {
+                    if (((resLimbs[limbIdx] >> i) & 1) == 1)
+                        s[bitIdx / 8] |= (byte) (1 << (bitIdx % 8));
+                    bitIdx++;
+                }
+            }
+        }
+    }
+
+    private static long load3(byte[] in, int off) {
+        return (in[off] & 0xffL) | ((in[off + 1] & 0xffL) << 8) | ((in[off + 2] & 0xffL) << 16);
+    }
+
+    private static long load4(byte[] in, int off) {
+        return (in[off] & 0xffL) | ((in[off + 1] & 0xffL) << 8) | ((in[off + 2] & 0xffL) << 16) | ((in[off + 3] & 0xffL) << 24);
+    }
+
+    private static void scalarMulAdd(byte[] S, byte[] k, byte[] s, byte[] r) {
+        long[] res = new long[64];
+        for (int i = 0; i < 32; i++) {
+            for (int j = 0; j < 32; j++) res[i + j] += (k[i] & 0xFFL) * (s[j] & 0xFFL);
+        }
+        for (int i = 0; i < 32; i++) res[i] += (r[i] & 0xFFL);
+        byte[] buffer = new byte[64];
+        long carry = 0;
+        for (int i = 0; i < 63; i++) {
+            long val = res[i] + carry;
+            buffer[i] = (byte) val;
+            carry = val >>> 8;
+        }
+        buffer[63] = (byte) (res[63] + carry);
+        reduceScalar(buffer);
+        System.arraycopy(buffer, 0, S, 0, 32);
+    }
+
+    private static byte[] sha512(byte[]... parts) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-512");
+            for (byte[] p : parts) md.update(p);
+            return md.digest();
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free 
+ *    Software Foundation, either version 3 of the License, or (at your option) 
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the 
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must 
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.crypto;
+
+import java.util.Arrays;
+import swiss.qpq.gajumaru.core.tools.CryptoUtils;
+
+
+// Pure Java implementation of Keccak-256 (Keccak[c=512] sponge).
+// Based on sha3.erl.
+
+public final class Keccak256 {
+
+    private static final int LANE_SIZE = 64;
+    private static final int STATE_SIZE = 25;
+    private static final int CAPACITY = 512;
+    private static final int BITRATE = 1600 - CAPACITY; // 1088 bits = 136 bytes
+    private static final int BITRATE_BYTES = BITRATE / 8;
+
+    private static final long[] ROUND_CONSTANTS = {
+        0x0000000000000001L, 0x0000000000008082L, 0x800000000000808AL, 0x8000000080008000L,
+        0x000000000000808BL, 0x0000000080000001L, 0x8000000080008081L, 0x8000000000008009L,
+        0x000000000000008AL, 0x0000000000000088L, 0x0000000080008009L, 0x000000008000000AL,
+        0x000000008000808BL, 0x800000000000008BL, 0x8000000000008089L, 0x8000000000008003L,
+        0x8000000000008002L, 0x8000000000000080L, 0x000000000000800AL, 0x800000008000000AL,
+        0x8000000080008081L, 0x8000000000008080L, 0x0000000080000001L, 0x8000000080008008L
+    };
+
+    private static final int[] ROTATION_OFFSETS = {
+         0,  1, 62, 28, 27,
+        36, 44,  6, 55, 20,
+         3, 10, 43, 25, 39,
+        41, 45, 15, 21,  8,
+        18,  2, 61, 56, 14
+    };
+
+    private Keccak256() {}
+
+    public static byte[] hash(byte[] data) {
+        long[] state = new long[STATE_SIZE];
+        
+        // Padding: Keccak[c=512] uses 0x01 ... 0x80 (or just 0x01 for non-NIST Keccak)
+        // Erlang code uses: keccak(Capacity, Message, <<>>, OutputBitLength)
+        // Pad logic in Erlang: <<Msg/bitstring, Delimiter/bitstring, 1:1, 0:PadZeros, 1:1>>
+        // With Delimiter = <<>>, it becomes <<1:1, 0:PadZeros, 1:1>> (standard Keccak padding)
+        
+        byte[] padded = pad(data, BITRATE_BYTES);
+        
+        for (int i = 0; i < padded.length; i += BITRATE_BYTES) {
+            absorb(state, padded, i);
+        }
+        
+        byte[] result = squeeze(state, 32);
+        
+        // Memory hygiene
+        Arrays.fill(state, 0L);
+        CryptoUtils.wipe(padded);
+        
+        return result;
+    }
+
+    private static byte[] pad(byte[] data, int rateBytes) {
+        int mLen = data.length;
+        int padLen = rateBytes - (mLen % rateBytes);
+        
+        byte[] padded = new byte[mLen + padLen];
+        System.arraycopy(data, 0, padded, 0, mLen);
+        
+        if (padLen == 1) {
+            padded[mLen] = (byte) 0x81;
+        } else {
+            padded[mLen] = (byte) 0x01;
+            padded[padded.length - 1] |= (byte) 0x80;
+        }
+        return padded;
+    }
+
+    private static void absorb(long[] state, byte[] data, int offset) {
+        for (int i = 0; i < BITRATE_BYTES / 8; i++) {
+            state[i] ^= readLongLittleEndian(data, offset + i * 8);
+        }
+        keccakF(state);
+    }
+
+    private static byte[] squeeze(long[] state, int len) {
+        byte[] result = new byte[len];
+        int count = 0;
+        while (count < len) {
+            for (int i = 0; i < BITRATE_BYTES / 8 && count < len; i++) {
+                writeLongLittleEndian(state[i], result, count);
+                count += 8;
+            }
+            if (count < len) {
+                keccakF(state);
+            }
+        }
+        return result;
+    }
+
+    private static void keccakF(long[] a) {
+        for (int round = 0; round < 24; round++) {
+            // Theta
+            long[] c = new long[5];
+            for (int x = 0; x < 5; x++) {
+                c[x] = a[x] ^ a[x + 5] ^ a[x + 10] ^ a[x + 15] ^ a[x + 20];
+            }
+            for (int x = 0; x < 5; x++) {
+                long d = c[(x + 4) % 5] ^ Long.rotateLeft(c[(x + 1) % 5], 1);
+                for (int y = 0; y < 5; y++) {
+                    a[x + y * 5] ^= d;
+                }
+            }
+
+            // Rho and Pi
+            long[] nextA = new long[STATE_SIZE];
+            for (int x = 0; x < 5; x++) {
+                for (int y = 0; y < 5; y++) {
+                    int index = x + y * 5;
+                    nextA[y + ((2 * x + 3 * y) % 5) * 5] = Long.rotateLeft(a[index], ROTATION_OFFSETS[index]);
+                }
+            }
+            
+            // Chi
+            for (int y = 0; y < 5; y++) {
+                long[] row = new long[5];
+                for (int x = 0; x < 5; x++) {
+                    row[x] = nextA[x + y * 5];
+                }
+                for (int x = 0; x < 5; x++) {
+                    nextA[x + y * 5] = row[x] ^ ((~row[(x + 1) % 5]) & row[(x + 2) % 5]);
+                }
+            }
+            
+            // Iota
+            nextA[0] ^= ROUND_CONSTANTS[round];
+            
+            System.arraycopy(nextA, 0, a, 0, STATE_SIZE);
+        }
+    }
+
+    private static long readLongLittleEndian(byte[] b, int offset) {
+        long res = 0;
+        for (int i = 0; i < 8; i++) {
+            res |= ((long) (b[offset + i] & 0xFF)) << (i * 8);
+        }
+        return res;
+    }
+
+    private static void writeLongLittleEndian(long v, byte[] b, int offset) {
+        for (int i = 0; i < 8; i++) {
+            b[offset + i] = (byte) ((v >>> (i * 8)) & 0xFF);
+        }
+    }
+}
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free 
+ *    Software Foundation, either version 3 of the License, or (at your option) 
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the 
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must 
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.data;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+
+// Port of gmser_id.erl.
+// Represents a 33-byte identifier (1-byte tag + 32-byte value).
+
+public final class Id {
+
+    public enum Tag {
+        ACCOUNT(1),
+        NAME(2),
+        COMMITMENT(3),
+        CONTRACT(5),
+        CHANNEL(6),
+        ASSOCIATE_CHAIN(7),
+        NATIVE_TOKEN(8),
+        ENTRY(9);
+
+        public final int value;
+
+        Tag(int value) {
+            this.value = value;
+        }
+
+        private static final Map<Integer, Tag> VALUE_MAP = new HashMap<>();
+        static {
+            for (Tag t : Tag.values()) {
+                VALUE_MAP.put(t.value, t);
+            }
+        }
+
+        public static Tag fromValue(int v) {
+            Tag t = VALUE_MAP.get(v);
+            if (t == null) throw new IllegalArgumentException("Unknown ID tag value: " + v);
+            return t;
+        }
+    }
+
+    private final Tag tag;
+    private final byte[] value;
+
+    public Id(Tag tag, byte[] value) {
+        if (value.length != 32) {
+            throw new IllegalArgumentException("ID value must be exactly 32 bytes");
+        }
+        this.tag = tag;
+        this.value = Arrays.copyOf(value, 32);
+    }
+
+    public Tag getTag() { return tag; }
+    public byte[] getValue() { return Arrays.copyOf(value, 32); }
+
+    public byte[] serialize() {
+        byte[] result = new byte[33];
+        result[0] = (byte) tag.value;
+        System.arraycopy(value, 0, result, 1, 32);
+        return result;
+    }
+
+    public static Id deserialize(byte[] data) {
+        if (data.length != 33) {
+            throw new IllegalArgumentException("Serialized ID must be exactly 33 bytes");
+        }
+        Tag tag = Tag.fromValue(data[0] & 0xFF);
+        byte[] value = Arrays.copyOfRange(data, 1, 33);
+        return new Id(tag, value);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Id)) return false;
+        Id id = (Id) o;
+        return tag == id.tag && Arrays.equals(value, id.value);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = tag.hashCode();
+        result = 31 * result + Arrays.hashCode(value);
+        return result;
+    }
+}
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free 
+ *    Software Foundation, either version 3 of the License, or (at your option) 
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the 
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must 
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.encoding;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+
+// Port of gmser_api_encoder.erl.
+// Handles Gajumaru API encoding (prefixed Base58Check).
+
+public final class ApiEncoder {
+
+    public enum Type {
+        ACCOUNT_PUBKEY("ak", 32),
+        ACCOUNT_SECKEY("sk", 32),
+        TX_HASH("th", 32),
+        CONTRACT_PUBKEY("ct", 32),
+        CHANNEL("ch", 32),
+        SIGNATURE("sg", 64),
+        KEY_BLOCK_HASH("kh", 32),
+        MICRO_BLOCK_HASH("mh", 32),
+        COMMITMENT("cm", 32),
+        PEER_PUBKEY("pp", 32),
+        NAME("nm", -1); // Variable size
+
+        public final String prefix;
+        public final int size;
+
+        Type(String prefix, int size) {
+            this.prefix = prefix;
+            this.size = size;
+        }
+    }
+
+    private static final Map<String, Type> PREFIX_MAP = new HashMap<>();
+    static {
+        for (Type t : Type.values()) {
+            PREFIX_MAP.put(t.prefix, t);
+        }
+    }
+
+    private ApiEncoder() {}
+
+    public static String encode(Type type, byte[] payload) {
+        if (type.size != -1 && payload.length != type.size) {
+            throw new IllegalArgumentException("Invalid payload size for " + type + ": " + payload.length);
+        }
+        return type.prefix + "_" + Base58.checkEncode(payload);
+    }
+
+    public static DecodeResult decode(String input) {
+        String[] parts = input.split("_");
+        if (parts.length != 2) {
+            throw new IllegalArgumentException("Invalid encoded string format");
+        }
+        
+        Type type = PREFIX_MAP.get(parts[0]);
+        if (type == null) {
+            throw new IllegalArgumentException("Unknown prefix: " + parts[0]);
+        }
+        
+        byte[] payload = Base58.checkDecode(parts[1]);
+        if (type.size != -1 && payload.length != type.size) {
+            throw new IllegalArgumentException("Invalid decoded payload size for " + type + ": " + payload.length);
+        }
+        
+        return new DecodeResult(type, payload);
+    }
+
+    public record DecodeResult(Type type, byte[] payload) {}
+}
@@ -24,6 +24,7 @@ import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;

+
 // Stateless Base58 and Base58Check implementation.

 public final class Base58 {
@@ -26,10 +26,7 @@ import java.util.List;

 public final class RLP {

-    // Integrated data models
    // RLP only has two types: byte arrays and lists of lists of byte arrays
-    // TODO: Comment this better with references.
-
    public static class RLPException extends RuntimeException {
        public RLPException(String message) {
            super(message);
@@ -110,12 +107,10 @@ public final class RLP {

        int prefix = buffer[offset] & 0xFF;

-        // 1. Single byte [0x00, 0x7F] (itself)
        if (prefix <= 0x7F) {
            return new DecodeResult(new RLP_Item(new byte[] { (byte) prefix }), 1);
        }

-        // 2. Short string [0x80, 0xB7] (length 0-55)
        if (prefix <= 0xB7) {
            int payloadLen = prefix - 0x80;
            checkBounds(buffer, offset + 1, payloadLen);
@@ -123,7 +118,6 @@ public final class RLP {
            return new DecodeResult(new RLP_Item(payload), 1 + payloadLen);
        }

-        // 3. Long string [0xB8, 0xBF] (length > 55)
        if (prefix <= 0xBF) {
            int lenLen = prefix - 0xB7;
            checkBounds(buffer, offset + 1, lenLen);
@@ -133,7 +127,6 @@ public final class RLP {
            return new DecodeResult(new RLP_Item(payload), 1 + lenLen + payloadLen);
        }

-        // 4. Short list [0xC0, 0xF7] (total length 0-55)
        if (prefix <= 0xF7) {
            int payloadLen = prefix - 0xC0;
            checkBounds(buffer, offset + 1, payloadLen);
@@ -141,7 +134,6 @@ public final class RLP {
            return new DecodeResult(list, 1 + payloadLen);
        }

-        // 5. Long list [0xF8, 0xFF] (total length > 55)
        int lenLen = prefix - 0xF7;
        checkBounds(buffer, offset + 1, lenLen);
        int payloadLen = bigEndianToInt(buffer, offset + 1, offset + 1 + lenLen);
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 QPQ AG <info@qpq.swiss>. All rights reserved.
+ * Project: Gajumaru Core Java Libraries <gajumaru.io>
+ *
+ * This program is dual-licensed:
+ * 1) Under the GNU Affero General Public License as published by the Free 
+ *    Software Foundation, either version 3 of the License, or (at your option) 
+ *    any later version (AGPL-3.0-or-later).
+ *
+ * 2) Under a commercial/proprietary license available directly from QPQ AG.
+ *    If you wish to use this software outside the strict constraints of the 
+ *    AGPLv3 (e.g. within a closed-source or proprietary product), you must 
+ *    purchase a commercial license from QPQ AG.
+ *
+ * Authors:
+ *   - Craig Everett <craigeverett@qpq.swiss>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-QPQ-Commercial
+ */
+
+package swiss.qpq.gajumaru.core.tools;
+
+import java.util.Arrays;
+
+
+// Utility class for cryptographic operations and memory hygiene.
+
+public final class CryptoUtils {
+
+    private CryptoUtils() {}
+
+    // Wipes a byte array by filling it with zeros.
+    public static void wipe(byte[] data) {
+        if (data != null) {
+            Arrays.fill(data, (byte) 0);
+        }
+    }
+
+    public static void wipe(long[] data) {
+        if (data != null) {
+            Arrays.fill(data, 0L);
+        }
+    }
+
+    public static String binToHex(byte[] data) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : data) {
+            sb.append(String.format("%02x", b & 0xff));
+        }
+        return sb.toString();
+    }
+
+    public static byte[] hexToBin(String s) {
+        int len = s.length();
+        byte[] data = new byte[len / 2];
+        for (int i = 0; i < len; i += 2) {
+            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+                                 + Character.digit(s.charAt(i+1), 16));
+        }
+        return data;
+    }
+}
@@ -13,3 +13,5 @@ doc/erlang.png
 rel/example_project
 .concrete/DEV_MODE
 .rebar
+.idea
+*.iml
@@ -0,0 +1,53 @@
+# GM Java <-> Erlang Tests
+
+The core Java libraries are all written as transform functions over data.
+There is little point, therefore, in obsessing over "unit tests" and "regression testing" of
+Java code in Java when we have cannonical code in Erlang.
+
+
+The purpose of this utility is to instead test the Java libraries agains the Erlang libraries
+directly.
+
+
+## How to run
+
+In the current directory simply run `zx runlocal` and the report map will be printed to the screen
+and random test data will be in the `temp/` directory.
+
+To run a specific test suite run `zx runlocal [module names]`.
+
+To list module names, run `zx runlocal list`.
+
+
+## Where things are
+
+The test cases are all generated in gmt.erl, generally based on randomized but valid data that
+are fed to reference Erlang implementations. Java code is built using plain old javac, and is
+handled by the `gajumaru-core/bin/compile` and `gajumaru-core/bin/run` scripts.
+
+The input to and output from each test is recorded to disk in the `temp/` dir.
+
+The inputs are then read in by equivalent Java functions and the output is then compared.
+
+For a test case to pass the outputs must be identical.
+
+
+## The Erlang execution context
+
+`zx` manages loading the execution context, so dependencies like gmserialization, ec_utils,
+base58, etc. (all of which are targets for which is increasingly turning into a Java port)
+are brought in dynamically and managed by `zx`. The easiest way to test a specific function
+in Java against the Erlang implementation is to add a call to it in gmt.erl and a matching
+call in `../src/Testinator.java`.
+
+The dependencies that are brought in can be listed with `zx list deps`.
+
+The package names follow the pattern `[realm]-[package_name]-[version]`
+
+The location of the sources varies on different systems.
+- Linux: `$HOME/zomp/lib/[realm]/[package_name]/[version]/src`
+- MacOS: `$HOME/.zx/zomp/lib/[realm]/[package_name]/[version]/src`
+- Windows: `%%LOCALAPPDATA%%/zomp/lib/[realm]/[package_name]/[version]/src`
+
+So for example `otpr-ec_utils-1.0.0` has its sources at `~/zomp/lib/otpr/ec_utils/1.0.0/src/`
+on a reasonable system.
@@ -0,0 +1,416 @@
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Base64;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Arrays;
+import java.math.BigInteger;
+
+import swiss.qpq.gajumaru.core.encoding.Base58;
+import swiss.qpq.gajumaru.core.encoding.RLP;
+import swiss.qpq.gajumaru.core.encoding.ApiEncoder;
+import swiss.qpq.gajumaru.core.formatting.GajuFormat;
+import swiss.qpq.gajumaru.core.crypto.Keccak256;
+import swiss.qpq.gajumaru.core.crypto.Blake2b;
+import swiss.qpq.gajumaru.core.crypto.Ed25519;
+import swiss.qpq.gajumaru.core.data.Id;
+import swiss.qpq.gajumaru.core.tools.CryptoUtils;
+
+public class Testinator {
+    public static void main(String[] args) {
+        if (args.length < 2) {
+            System.out.println("Error: Provide the test suite name and the required arguments.");
+            System.exit(1);
+        }
+
+        try {
+            switch (args[0]) {
+                case "base64"           -> { System.out.print(base64(args[1])); }
+                case "base58"           -> { System.out.print(base58(args[1])); }
+                case "base58_check"     -> { System.out.print(base58_check(args[1])); }
+                case "rlp"              -> { System.out.print(rlp(args[1])); }
+                case "rlp_stream"       -> { System.out.print(rlp_stream(args[1])); }
+                case "rlp_fail"         -> { System.out.print(rlp_fail(args[1])); }
+                case "gaju_format"      -> { System.out.print(gaju_format(args[1])); }
+                case "keccak256"        -> { System.out.print(keccak256(args[1])); }
+                case "blake2b"          -> { System.out.print(blake2b(args[1])); }
+                case "ed25519"          -> { System.out.print(ed25519(args[1])); }
+                case "ed25519_verify"   -> { System.out.print(ed25519_verify(args[1])); }
+                case "api_encode"       -> { System.out.print(api_encode(args[1])); }
+                case "id_serialization" -> { System.out.print(id_serialization(args[1])); }
+                case "fe_parity"        -> { System.out.print(fe_parity(args[1])); }
+                case "reduce_parity"    -> { System.out.print(reduce_parity(args[1])); }
+                case "smb_parity"       -> { System.out.print(smb_parity(args[1])); }
+                case "femul_parity"     -> { System.out.print(femul_parity(args[1])); }
+                case "frombytes_parity" -> { System.out.print(frombytes_parity(args[1])); }
+                case "ge_parity"        -> { System.out.print(ge_parity(args[1], args[2])); }
+                case "keccak" -> {
+                    byte[] in = CryptoUtils.hexToBin(args[1]);
+                    System.out.println(CryptoUtils.binToHex(Keccak256.hash(in)));
+                }
+                case "blake2b_direct" -> {
+                    byte[] in = CryptoUtils.hexToBin(args[1]);
+                    System.out.println(CryptoUtils.binToHex(Blake2b.hash(in)));
+                }
+                case "ak_encode" -> {
+                    byte[] in = CryptoUtils.hexToBin(args[1]);
+                    System.out.println(ApiEncoder.encode(ApiEncoder.Type.ACCOUNT_PUBKEY, in));
+                }
+                case "ed25519_pub" -> {
+                    byte[] seed = CryptoUtils.hexToBin(args[1]);
+                    System.out.println(CryptoUtils.binToHex(Ed25519.publicKey(seed)));
+                }
+                case "id_serialize" -> {
+                    int tag = Integer.parseInt(args[1]);
+                    byte[] val = CryptoUtils.hexToBin(args[2]);
+                    Id id = new Id(Id.Tag.fromValue(tag), val);
+                    System.out.println(CryptoUtils.binToHex(id.serialize()));
+                }
+                default -> {
+                    System.out.println("Error: Unknown test suite or command: " + args[0]);
+                    System.exit(1);
+                }
+            }
+        } catch (Exception e) {
+            System.err.println("Error: " + e.getMessage());
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    private static String ge_parity(String aHex, String bHex) throws IOException {
+        byte[] a = CryptoUtils.hexToBin(aHex);
+        byte[] b = CryptoUtils.hexToBin(bHex);
+
+        Ed25519.Scratch sc = new Ed25519.Scratch();
+        Ed25519.Ge p1 = Ed25519.scalarMulBase(a, sc);
+        Ed25519.Ge p2 = Ed25519.scalarMulBase(b, sc);
+        Ed25519.Ge p3 = new Ed25519.Ge();
+        Ed25519.ge_add(p3, p1, p2, sc);
+        byte[] res = Ed25519.compress(p3, sc);
+        p1.wipe(); p2.wipe(); p3.wipe(); sc.wipe();
+        
+        return CryptoUtils.binToHex(res) + "|||";
+    }
+
+    private static String frombytes_parity(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "frombytes.test");
+        Path resPath  = Path.of(workingPath, "frombytes.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String hex : lines) {
+            if (hex.trim().isEmpty()) continue;
+            byte[] in = CryptoUtils.hexToBin(hex);
+            long[] h = new long[10];
+            Ed25519.fe_frombytes(h, in);
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < 10; i++) {
+                if (i > 0) sb.append(",");
+                sb.append(h[i]);
+            }
+            results.add(sb.toString());
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String femul_parity(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "femul.test");
+        Path resPath  = Path.of(workingPath, "femul.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String line : lines) {
+            if (line.trim().isEmpty()) continue;
+            String[] parts = line.split("\\|");
+            byte[] a = CryptoUtils.hexToBin(parts[0]);
+            byte[] b = CryptoUtils.hexToBin(parts[1]);
+            
+            long[] ha = new long[10], hb = new long[10];
+            Ed25519.fe_frombytes(ha, a);
+            Ed25519.fe_frombytes(hb, b);
+            long[] hr = new long[10];
+            Ed25519.fe_mul(hr, ha, hb, new long[19]);
+            byte[] out = Ed25519.fe_contract(hr);
+            
+            results.add(CryptoUtils.binToHex(out));
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String smb_parity(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "smb.test");
+        Path resPath  = Path.of(workingPath, "smb.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String hex : lines) {
+            if (hex.trim().isEmpty()) continue;
+            byte[] in = CryptoUtils.hexToBin(hex);
+            
+            Ed25519.Scratch sc = new Ed25519.Scratch();
+            Ed25519.Ge p = Ed25519.scalarMulBase(in, sc);
+            byte[] out = Ed25519.compress(p, sc);
+            p.wipe(); sc.wipe();
+            
+            results.add(CryptoUtils.binToHex(out));
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String reduce_parity(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "reduce.test");
+        Path resPath  = Path.of(workingPath, "reduce.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String hex : lines) {
+            if (hex.trim().isEmpty()) continue;
+            byte[] in = CryptoUtils.hexToBin(hex);
+            
+            byte[] s = Arrays.copyOf(in, 64);
+            Ed25519.reduceScalar(s);
+            byte[] out = Arrays.copyOf(s, 32);
+            
+            results.add(CryptoUtils.binToHex(out));
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String fe_parity(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "fe.test");
+        Path resPath  = Path.of(workingPath, "fe.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String hex : lines) {
+            if (hex.trim().isEmpty()) continue;
+            byte[] in = CryptoUtils.hexToBin(hex);
+            
+            long[] h = new long[10];
+            Ed25519.fe_frombytes(h, in);
+            byte[] out = Ed25519.fe_contract(h);
+            
+            results.add(CryptoUtils.binToHex(out));
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String base64(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "base64.test");
+        Path encPath  = Path.of(workingPath, "base64.java.txt");
+        Path decPath  = Path.of(workingPath, "base64.java.back");
+        byte[] rawB   = Files.readAllBytes(testPath);
+        byte[] encB   = Base64.getEncoder().encode(rawB);
+        Files.write(encPath, encB);
+        byte[] readE  = Files.readAllBytes(encPath);
+        byte[] decB   = Base64.getDecoder().decode(readE);
+        Files.write(decPath, decB);
+        return encPath.toString() + " " + decPath.toString();
+    }
+
+    private static String base58(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "base58.test");
+        Path encPath  = Path.of(workingPath, "base58.java.txt");
+        Path decPath  = Path.of(workingPath, "base58.java.back");
+        byte[] rawB   = Files.readAllBytes(testPath);
+        String encS   = Base58.encode(rawB);
+        Files.write(encPath, encS.getBytes());
+        byte[] readE  = Files.readAllBytes(encPath);
+        String readS  = new String(readE);
+        byte[] decB   = Base58.decode(readS);
+        Files.write(decPath, decB);
+        return encPath.toString() + " " + decPath.toString();
+    }
+
+    private static String base58_check(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "base58_check.test");
+        Path encPath  = Path.of(workingPath, "base58_check.java.txt");
+        Path decPath  = Path.of(workingPath, "base58_check.java.back");
+        byte[] rawB   = Files.readAllBytes(testPath);
+        String encS   = Base58.checkEncode(rawB);
+        Files.write(encPath, encS.getBytes());
+        byte[] readE  = Files.readAllBytes(encPath);
+        String readS  = new String(readE);
+        byte[] decB   = Base58.checkDecode(readS);
+        Files.write(decPath, decB);
+        return encPath.toString() + " " + decPath.toString();
+    }
+
+    private static String rlp(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "rlp.test");
+        Path resPath  = Path.of(workingPath, "rlp.java.back");
+        byte[] encB   = Files.readAllBytes(testPath);
+        
+        RLP.RLP_Data decRLP = RLP.decode(encB);
+        
+        RLP.RLP_List root = decRLP.asList();
+        RLP.RLP_List sub  = root.getItems().get(1).asList();
+        byte[] anchor     = sub.getItems().get(1).asItem().getBytes();
+        
+        byte[] reEnc = RLP.encode(decRLP);
+        Files.write(resPath, reEnc);
+        
+        return new String(anchor) + "|" + resPath.toString();
+    }
+
+    private static String rlp_stream(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "rlp_stream.test");
+        byte[] buffer = Files.readAllBytes(testPath);
+        
+        List<String> hashes = new ArrayList<>();
+        int offset = 0;
+        while (offset < buffer.length) {
+            RLP.DecodeResult res = RLP.decodeFrom(buffer, offset);
+            hashes.add(Integer.toString(res.data().hashCode())); // Just to verify we got objects
+            offset += res.consumed();
+        }
+        return Integer.toString(hashes.size());
+    }
+
+    private static String rlp_fail(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "rlp_fail.test");
+        byte[] buffer = Files.readAllBytes(testPath);
+        try {
+            RLP.decode(buffer);
+            return "SUCCESS";
+        } catch (RLP.RLPException e) {
+            return "RLP_EXCEPTION: " + e.getMessage();
+        } catch (Exception e) {
+            return "OTHER_EXCEPTION: " + e.getClass().getSimpleName();
+        }
+    }
+
+    private static String gaju_format(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "gaju_format.test");
+        Path resPath  = Path.of(workingPath, "gaju_format.java.txt");
+        List<String> lines   = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        
+        for (String line : lines) {
+            if (line.trim().isEmpty()) continue;
+            String[] p = line.split("\\|");
+            String op  = p[0];
+            switch (op) {
+                case "amount" -> {
+                    GajuFormat.Type style = GajuFormat.Type.valueOf(p[1]);
+                    GajuFormat.Unit unit  = GajuFormat.Unit.valueOf(p[2]);
+                    char sep = p[3].charAt(0);
+                    int span = Integer.parseInt(p[4]);
+                    BigInteger val = new BigInteger(p[5]);
+                    results.add(GajuFormat.amount(new GajuFormat.FormatSpec(style, unit, sep, span), val));
+                }
+                case "approx" -> {
+                    GajuFormat.Type style = GajuFormat.Type.valueOf(p[1]);
+                    GajuFormat.Unit unit  = GajuFormat.Unit.valueOf(p[2]);
+                    char sep = p[3].charAt(0);
+                    int span = Integer.parseInt(p[4]);
+                    BigInteger val = new BigInteger(p[5]);
+                    int prec = Integer.parseInt(p[6]);
+                    results.add(GajuFormat.approxAmount(new GajuFormat.FormatSpec(style, unit, sep, span), val, prec));
+                }
+                case "read" -> {
+                    byte[] b = GajuFormat.read(p[1]);
+                    results.add(new BigInteger(b).toString());
+                }
+            }
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String keccak256(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "keccak256.test");
+        Path resPath  = Path.of(workingPath, "keccak256.java.txt");
+        byte[] input  = Files.readAllBytes(testPath);
+        byte[] hash   = Keccak256.hash(input);
+        Files.write(resPath, CryptoUtils.binToHex(hash).getBytes());
+        return resPath.toString();
+    }
+
+    private static String blake2b(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "blake2b.test");
+        Path resPath  = Path.of(workingPath, "blake2b.java.txt");
+        byte[] input  = Files.readAllBytes(testPath);
+        byte[] hash   = Blake2b.hash(input);
+        Files.write(resPath, CryptoUtils.binToHex(hash).getBytes());
+        return resPath.toString();
+    }
+
+    private static String ed25519(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "ed25519.test");
+        Path resPath  = Path.of(workingPath, "ed25519.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String line : lines) {
+            if (line.trim().isEmpty()) continue;
+            String[] parts = line.split("\\|");
+            byte[] seed = CryptoUtils.hexToBin(parts[0]);
+            byte[] msg  = CryptoUtils.hexToBin(parts[1]);
+            
+            byte[] pub = Ed25519.publicKey(seed);
+            byte[] sig = Ed25519.sign(seed, msg);
+            boolean verify = Ed25519.verify(pub, msg, sig);
+            
+            results.add(CryptoUtils.binToHex(pub) + "|" + CryptoUtils.binToHex(sig) + "|" + verify);
+            
+            CryptoUtils.wipe(seed);
+            CryptoUtils.wipe(msg);
+            CryptoUtils.wipe(pub);
+            CryptoUtils.wipe(sig);
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String ed25519_verify(String workingPath) throws IOException {
+        Path seedPath = Path.of(workingPath, "ed25519_seed.test");
+        Path msgPath  = Path.of(workingPath, "ed25519_msg.test");
+        
+        byte[] seed    = CryptoUtils.hexToBin(Files.readString(seedPath).trim());
+        byte[] message = Files.readAllBytes(msgPath);
+        
+        byte[] pub = Ed25519.publicKey(seed);
+        byte[] sig = Ed25519.sign(seed, message);
+        boolean verify = Ed25519.verify(pub, message, sig);
+        
+        return CryptoUtils.binToHex(pub) + "|" + CryptoUtils.binToHex(sig) + "|" + verify;
+    }
+
+    private static String api_encode(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "api_encode.test");
+        Path resPath  = Path.of(workingPath, "api_encode.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String line : lines) {
+            if (line.trim().isEmpty()) continue;
+            String[] p = line.split("\\|");
+            ApiEncoder.Type type = ApiEncoder.Type.valueOf(p[0]);
+            byte[] payload = CryptoUtils.hexToBin(p[1]);
+            results.add(ApiEncoder.encode(type, payload));
+            if (type == ApiEncoder.Type.ACCOUNT_SECKEY) {
+                CryptoUtils.wipe(payload);
+            }
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+
+    private static String id_serialization(String workingPath) throws IOException {
+        Path testPath = Path.of(workingPath, "id_serialization.test");
+        Path resPath  = Path.of(workingPath, "id_serialization.java.txt");
+        List<String> lines = Files.readAllLines(testPath);
+        List<String> results = new ArrayList<>();
+        for (String line : lines) {
+            if (line.trim().isEmpty()) continue;
+            String[] p = line.split("\\|");
+            Id.Tag tag = Id.Tag.fromValue(Integer.parseInt(p[0]));
+            byte[] val = CryptoUtils.hexToBin(p[1]);
+            Id id = new Id(tag, val);
+            results.add(CryptoUtils.binToHex(id.serialize()));
+        }
+        Files.write(resPath, results);
+        return resPath.toString();
+    }
+}
@@ -0,0 +1,588 @@
+%%% @doc
+%%% Gajumaru Java Lib Tester: gmt
+%%%
+%%% This module provides an inter-language test suite for the Gajumaru core
+%%% Java libraries. It tests the Java implementation against the canonical
+%%% Erlang implementation by generating random test vectors and comparing
+%%% the outputs.
+%%% @end
+
+-module(gmt).
+-vsn("0.1.0").
+-author("Craig Everett <craigeverett@qpq.swiss>").
+-copyright("Craig Everett <craigeverett@qpq.swiss>").
+-license("LGPL-3.0-or-later").
+
+-export([start/1]).
+
+
+%%% Logic
+
+mods() ->
+    #{"base64"              => fun base64/0,
+      "base58"              => fun base58/0,
+      "base58_check"        => fun base58_check/0,
+      "rlp"                 => fun rlp/0,
+      "rlp_stream"          => fun rlp_stream/0,
+      "rlp_fail"            => fun rlp_fail/0,
+      "gaju_format"         => fun gaju_format/0,
+      "keccak256"           => fun keccak256/0,
+      "blake2b"             => fun blake2b/0,
+      "ed25519"             => fun ed25519/0,
+      "api_encode"          => fun api_encode/0,
+      "id_serialization"    => fun id_serialization/0,
+      "fe_parity"           => fun fe_parity/0,
+      "reduce_parity"       => fun reduce_parity/0,
+      "smb_parity"          => fun smb_parity/0,
+      "femul_parity"        => fun femul_parity/0,
+      "frombytes_parity"    => fun frombytes_parity/0,
+      "ge_parity"           => fun ge_parity/0}.
+
+
+start([]) ->
+    Tests = mods(),
+    ok = run(Tests),
+    zx:silent_stop();
+start(["list"]) ->
+    ok = io:format("Available tests:~n"),
+    ok = lists:foreach(fun display/1, maps:keys(mods())),
+    zx:silent_stop();
+start(Mods) ->
+    Available = mods(),
+    Tests = maps:with(Mods, Available),
+    ok =
+        case maps:size(Tests) =:= length(Mods) of
+            true ->
+                run(Tests);
+            false ->
+                NotMods = lists:subtract(Mods, maps:keys(Available)),
+                ok = io:format("The following arguments are not testable module names:~n"),
+                lists:foreach(fun display/1, NotMods)
+        end,
+    zx:silent_stop().
+
+display(Name) ->
+    io:format("  ~ts~n", [Name]).
+
+run(Tests) ->
+    {ok, Cwd} = file:get_cwd(),
+    ok =
+        case filename:basename(Cwd) of
+            "test" -> file:set_cwd("..");
+            _      -> ok
+        end,
+
+    ok = clean(),
+    ok = build(),
+    Results = maps:map(fun run/2, Tests),
+    io:format("~nFinal Results:~n ~tp~n", [Results]).
+
+run(Name, Test) ->
+    ok = io:format("~nRunning: ~ts...~n", [Name]),
+    Test().
+
+clean() ->
+    Temp = "test/temp",
+    lists:foreach(fun(D) -> ok = clean(D) end, [Temp]).
+
+clean(Dir) ->
+    case file:del_dir_r(Dir) of
+        ok              -> ok;
+        {error, enoent} -> ok;
+        Error           -> Error
+    end.
+
+build() ->
+    Out = os:cmd("bin/compile"),
+    io:format("Compile: ~ts", [Out]).
+
+temp_dir() ->
+    {ok, Cwd} = file:get_cwd(),
+    filename:join(Cwd, "test/temp").
+
+trim(S) ->
+    Unprintable = fun(C) -> C =< 32 end,
+    lists:reverse(lists:dropwhile(Unprintable, lists:reverse(lists:dropwhile(Unprintable, S)))).
+
+
+
+%%% Test Modules
+
+base64() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "base64.test"),
+    ConvFile = filename:join(Temp, "base64.erlang.txt"),
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
+    {ok, B} = file:read_file(TestFile),
+    Base64 = base64:encode(B),
+    ok = file:write_file(ConvFile, Base64),
+    Run = "bin/run base64 " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    [JEnc, JDec] = string:split(Out, " "),
+    {ok, EEncB} = file:read_file(ConvFile),
+    {ok, JEncB} = file:read_file(JEnc),
+    EHash = crypto:hash(sha512, EEncB),
+    JHash = crypto:hash(sha512, JEncB),
+    {ok, EDecB} = file:read_file(TestFile),
+    {ok, JDecB} = file:read_file(JDec),
+    EBinHash = crypto:hash(sha512, EDecB),
+    JBinHash = crypto:hash(sha512, JDecB),
+    EHash =:= JHash andalso EBinHash =:= JBinHash.
+
+
+base58() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "base58.test"),
+    ConvFile = filename:join(Temp, "base58.erlang.txt"),
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
+    {ok, B} = file:read_file(TestFile),
+    Base58 = base58:binary_to_base58(B),
+    ok = file:write_file(ConvFile, Base58),
+    Run = "bin/run base58 " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    [JEnc, JDec] = string:split(Out, " "),
+    {ok, EEncB} = file:read_file(ConvFile),
+    {ok, JEncB} = file:read_file(JEnc),
+    EHash = crypto:hash(sha512, EEncB),
+    JHash = crypto:hash(sha512, JEncB),
+    {ok, EDecB} = file:read_file(TestFile),
+    {ok, JDecB} = file:read_file(JDec),
+    EBinHash = crypto:hash(sha512, EDecB),
+    JBinHash = crypto:hash(sha512, JDecB),
+    EHash =:= JHash andalso EBinHash =:= JBinHash.
+
+
+base58_check() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "base58_check.test"),
+    ConvFile = filename:join(Temp, "base58_check.erlang.txt"),
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, rand:bytes(rand:uniform(5000))),
+    {ok, B} = file:read_file(TestFile),
+    Checksum = binary:part(crypto:hash(sha256, crypto:hash(sha256, B)), 0, 4),
+    Base58C = base58:binary_to_base58(<<B/binary, Checksum/binary>>),
+    ok = file:write_file(ConvFile, Base58C),
+    Run = "bin/run base58_check " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    [JEnc, JDec] = string:split(Out, " "),
+    {ok, EEncB} = file:read_file(ConvFile),
+    {ok, JEncB} = file:read_file(JEnc),
+    EHash = crypto:hash(sha512, EEncB),
+    JHash = crypto:hash(sha512, JEncB),
+    {ok, EDecB} = file:read_file(TestFile),
+    {ok, JDecB} = file:read_file(JDec),
+    EBinHash = crypto:hash(sha512, EDecB),
+    JBinHash = crypto:hash(sha512, JDecB),
+    EHash =:= JHash andalso EBinHash =:= JBinHash.
+
+
+rlp() ->
+    Temp = temp_dir(),
+    Anchor = <<"I thought what I'd do was, I'd pretend I was one of those deaf-mutes.">>,
+    Data =
+        [rand:bytes(rand:uniform(20)),
+         [rand:bytes(rand:uniform(20)),
+          Anchor,
+          rand:bytes(rand:uniform(20)),
+          rand:bytes(rand:uniform(5000))],
+         rand:bytes(rand:uniform(2000))],
+    RLP = gmser_rlp:encode(Data),
+    RLP_File = filename:join(Temp, "rlp.test"),
+    ok = filelib:ensure_dir(RLP_File),
+    ok = file:write_file(RLP_File, RLP),
+    Run = "bin/run rlp " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    case string:split(Out, "|") of
+        [Found, JPath] ->
+            JPathTrimmed = trim(JPath),
+            {ok, EEncB} = file:read_file(RLP_File),
+            case file:read_file(JPathTrimmed) of
+                {ok, JEncB} ->
+                    EHash = crypto:hash(sha512, EEncB),
+                    JHash = crypto:hash(sha512, JEncB),
+                    EHash =:= JHash andalso Found =:= unicode:characters_to_list(Anchor);
+                {error, R} ->
+                    ok = io:format("Failed to read RLP Java result: ~tp (Path: ~tp)~n", [R, JPathTrimmed]),
+                    false
+            end;
+        _ ->
+            ok = io:format("RLP output mismatch: ~tp~n", [Out]),
+            false
+    end.
+
+
+rlp_stream() ->
+    Temp     = temp_dir(),
+    TestFile = filename:join(Temp, "rlp_stream.test"),
+    ok       = filelib:ensure_dir(TestFile),
+    Data     = [rand:bytes(rand:uniform(100)) || _ <- lists:seq(1, 10)],
+    RLP      = << <<(gmser_rlp:encode(D))/binary>> || D <- Data >>,
+    ok       = file:write_file(TestFile, RLP),
+    Run      = "bin/run rlp_stream " ++ Temp,
+    Out      = trim(os:cmd(Run)),
+    Out =:= "10".
+
+
+rlp_fail() ->
+    Temp     = temp_dir(),
+    TestFile = filename:join(Temp, "rlp_fail.test"),
+    ok       = filelib:ensure_dir(TestFile),
+    Data     = [<<"item1">>, <<"item2">>],
+    FullRLP  = gmser_rlp:encode(Data),
+    TruncRLP = binary:part(FullRLP, 0, byte_size(FullRLP) - 2),
+    ok       = file:write_file(TestFile, TruncRLP),
+    Run      = "bin/run rlp_fail " ++ Temp,
+    Out      = trim(os:cmd(Run)),
+    string:prefix(Out, "RLP_EXCEPTION:") =/= nomatch.
+
+
+gaju_format() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "gaju_format.test"),
+    ok = filelib:ensure_dir(TestFile),
+    Cases = [gen_case() || _ <- lists:seq(1, 100)],
+    Lines = [serialize_case(C) || C <- Cases],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[L, "\n"] || L <- Lines])),
+    Run = "bin/run gaju_format " ++ Temp,
+    RawOut = os:cmd(Run),
+    JavaResPath = trim(RawOut),
+    case file:read_file(JavaResPath) of
+        {ok, ResContent} ->
+            JavaResults = string:split(trim(unicode:characters_to_list(ResContent)), "\n", all),
+            length(Cases) =:= length(JavaResults) andalso compare_results(Cases, JavaResults);
+        {error, Reason} ->
+            Format = "Failed to read Java results from: ~tp (Reason: ~tp)~nRaw Output: ~ts~n",
+            io:format(Format, [JavaResPath, Reason, RawOut]),
+            false
+    end.
+
+
+keccak256() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "keccak256.test"),
+    ResFile = filename:join(Temp, "keccak256.erlang.txt"),
+    Data = rand:bytes(rand:uniform(5000)),
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, Data),
+    Hash = sha3:hash(256, Data),
+    HexHash = bin_to_hex(Hash),
+    ok = file:write_file(ResFile, HexHash),
+    Run = "bin/run keccak256 " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOut} = file:read_file(trim(Out)),
+    unicode:characters_to_list(JOut) =:= HexHash.
+
+
+blake2b() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "blake2b.test"),
+    ResFile = filename:join(Temp, "blake2b.erlang.txt"),
+    Data = rand:bytes(rand:uniform(5000)),
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, Data),
+    {ok, Hash} = eblake2:blake2b(32, Data),
+    HexHash = bin_to_hex(Hash),
+    ok = file:write_file(ResFile, HexHash),
+    Run = "bin/run blake2b " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOut} = file:read_file(trim(Out)),
+    unicode:characters_to_list(JOut) =:= HexHash.
+
+
+ed25519() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "ed25519.test"),
+    ok = filelib:ensure_dir(TestFile),
+    Cases = [{rand:bytes(32), rand:bytes(rand:uniform(100))} || _ <- lists:seq(1, 20)],
+    ok = file:write_file(TestFile, [[bin_to_hex(S), "|", bin_to_hex(M), "\n"] || {S, M} <- Cases]),
+    Sequence =
+        fun({S, M}) ->
+            #{public := Pub} = ecu_eddsa:sign_seed_keypair(S),
+            Sig = ecu_eddsa:sign_detached(M, S),
+            V = ecu_eddsa:sign_verify_detached(Sig, M, Pub),
+            lists:flatten(io_lib:format("~s|~s|~p", [bin_to_hex(Pub), bin_to_hex(Sig), V]))
+        end,
+    Expected = lists:map(Sequence, Cases),
+    Run = "bin/run ed25519 " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = [trim(L) || L <- string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all)],
+    same_same(Expected, JResults).
+
+
+api_encode() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "api_encode.test"),
+    Types = [account_pubkey, account_seckey, tx_hash, contract_pubkey, signature, commitment, peer_pubkey],
+    Cases = [{T, rand:bytes(type_size(T))} || T <- Types],
+    Lines = [io_lib:format("~ts|~ts", [string:uppercase(atom_to_list(T)), bin_to_hex(B)]) || {T, B} <- Cases],
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[L, "\n"] || L <- Lines])),
+    Expected = [flatten(gmser_api_encoder:encode(T, B)) || {T, B} <- Cases],
+    Run = "bin/run api_encode " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    same_same(Expected, JResults).
+
+type_size(signature) -> 64;
+type_size(_)         -> 32.
+
+
+id_serialization() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "id_serialization.test"),
+    Tags = [1, 2, 3, 5, 6, 7, 9],
+    Cases = [{Tag, rand:bytes(32)} || Tag <- Tags],
+    Lines = [io_lib:format("~b|~ts", [Tag, bin_to_hex(B)]) || {Tag, B} <- Cases],
+    ok = filelib:ensure_dir(TestFile),
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[L, "\n"] || L <- Lines])),
+    Expected = [bin_to_hex(gmser_id:encode(gmser_id:decode(<<T:8, B/binary>>))) || {T, B} <- Cases],
+    Run = "bin/run id_serialization " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    same_same(Expected, JResults).
+
+
+fe_parity() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "fe.test"),
+    ok = filelib:ensure_dir(TestFile),
+    % Mask to 255 bits to avoid bit-255 sign bit ambiguity in fe_frombytes
+    RandomLittleFingers =
+        fun() ->
+            <<B:256/little>> = rand:bytes(32),
+            bin_to_hex(<<(B band ((1 bsl 255) - 1)):256/little>>)
+        end,
+    Inputs = [RandomLittleFingers() || _ <- lists:seq(1, 100)],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[I, "\n"] || I <- Inputs])),
+    Run = "bin/run fe_parity " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    P = ecu_ed25519:p(),
+    Pee =
+        fun(I) ->
+            <<B:256/little>> = hex_to_bin(I),
+            bin_to_hex(pack_p(B rem P))
+        end,
+    Expected = lists:map(Pee, Inputs),
+    same_same(Expected, JResults).
+
+
+reduce_parity() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "reduce.test"),
+    ok = filelib:ensure_dir(TestFile),
+    Inputs = [rand:bytes(64) || _ <- lists:seq(1, 100)],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[bin_to_hex(I), "\n"] || I <- Inputs])),
+    Run = "bin/run reduce_parity " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    Expected = [bin_to_hex(ecu_ed25519:scalar_reduce(I)) || I <- Inputs],
+    same_same(Expected, JResults).
+
+
+smb_parity() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "smb.test"),
+    ok = filelib:ensure_dir(TestFile),
+    Inputs = [<<(rand:bytes(31))/binary, 0>> || _ <- lists:seq(1, 10)],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[bin_to_hex(I), "\n"] || I <- Inputs])),
+    Run = "bin/run smb_parity " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    Expected = [bin_to_hex(ecu_ed25519:compress(ecu_ed25519:scalar_mul_base_noclamp(I))) || I <- Inputs],
+    same_same(Expected, JResults).
+
+
+femul_parity() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "femul.test"),
+    ok = filelib:ensure_dir(TestFile),
+    % Mask to 255 bits
+    Gen = fun() -> <<B:256/little>> = rand:bytes(32), << (B band ((1 bsl 255) - 1)):256/little >> end,
+    Inputs = [{Gen(), Gen()} || _ <- lists:seq(1, 10)],
+    Lines = [bin_to_hex(A) ++ "|" ++ bin_to_hex(B) || {A, B} <- Inputs],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[L, "\n"] || L <- Lines])),
+    Run = "bin/run femul_parity " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    ExpectedBin = [bin_to_hex(pack_p(ecu_ed25519:f_mul(binary:decode_unsigned(A, little), binary:decode_unsigned(B, little)))) || {A, B} <- Inputs],
+    same_same3(Inputs, ExpectedBin, JResults).
+
+
+same_same3(AB, L1, L2) ->
+    same_same3(AB, L1, L2, true).
+
+same_same3([_ | R1], [S | R2], [S | R3], Result) ->
+    same_same3(R1, R2, R3, Result);
+same_same3([{A, B} | R1], [E | R2], [J | R3], _) ->
+    ok = io:format("A: ~ts~nB: ~ts~nE: ~ts~nJ: ~ts~n", [bin_to_hex(A), bin_to_hex(B), E, J]),
+    same_same3(R1, R2, R3, false);
+same_same3([], [], [], Result) ->
+    Result.
+
+
+same_same(L1, L2) ->
+    same_same(L1, L2, true).
+
+same_same([S | R1], [S | R2], Result) ->
+    same_same(R1, R2, Result);
+same_same([E | R1], [J | R2], _) ->
+    ok = io:format("Mismatch!\nE: ~ts\nJ: ~ts\n", [E, J]),
+    same_same(R1, R2, false);
+same_same([], [], Result) ->
+    Result.
+
+
+frombytes_parity() ->
+    Temp = temp_dir(),
+    TestFile = filename:join(Temp, "frombytes.test"),
+    ok = filelib:ensure_dir(TestFile),
+    Inputs = [rand:bytes(32) || _ <- lists:seq(1, 10)],
+    ok = file:write_file(TestFile, unicode:characters_to_binary([[bin_to_hex(I), "\n"] || I <- Inputs])),
+    Run = "bin/run frombytes_parity " ++ Temp,
+    Out = trim(os:cmd(Run)),
+    {ok, JOutContent} = file:read_file(trim(Out)),
+    JResults = string:split(trim(unicode:characters_to_list(JOutContent)), "\n", all),
+    Limb =
+        fun(I) ->
+            Val = binary:decode_unsigned(I, little),
+            Limbs =
+                fun
+                    F(V, Idx) when Idx < 10 ->
+                        Size =
+                            case Idx rem 2 =:= 0 of
+                                true  -> 26;
+                                false -> 25 
+                            end,
+                        L = V band ((1 bsl Size) - 1),
+                        [L | F(V bsr Size, Idx + 1)];
+                    F(_, _) ->
+                        []
+                end,
+            string:join([integer_to_list(L) || L <- Limbs(Val, 0)], ",")
+        end,
+    Expected = lists:map(Limb, Inputs),
+    same_same(Expected, JResults).
+
+
+ge_parity() ->
+    A_bin = <<1, 2, 3, 0:232>>,
+    B_bin = <<4, 5, 6, 0:232>>,
+    P1_erl = ecu_ed25519:scalar_mul_base_noclamp(A_bin),
+    P2_erl = ecu_ed25519:scalar_mul_base_noclamp(B_bin),
+    P3_erl = ecu_ed25519:p_add(P1_erl, P2_erl),
+    E_comp = bin_to_hex(ecu_ed25519:compress(P3_erl)),
+    Run = "bin/run ge_parity " ++ bin_to_hex(A_bin) ++ " " ++ bin_to_hex(B_bin),
+    Out = trim(os:cmd(Run)),
+    case string:split(Out, "|||") of
+        [JX | _] -> E_comp =:= trim(JX);
+        _        -> false
+    end.
+
+pack_p(V) ->
+    P = (1 bsl 255) - 19,
+    V_pos = if V < 0 -> V + P; true -> V rem P end,
+    Enc = binary:encode_unsigned(V_pos, little),
+    Size = byte_size(Enc),
+    if Size < 32 -> <<Enc/binary, 0:(8*(32-Size))>>; true -> Enc end.
+
+bin_to_hex(Bin) ->
+    lists:flatten([io_lib:format("~2.16.0b", [X]) || X <- binary_to_list(Bin)]).
+
+hex_to_bin(S) ->
+    hex_to_bin(S, []).
+hex_to_bin([], Acc) ->
+    list_to_binary(lists:reverse(Acc));
+hex_to_bin([X,Y|T], Acc) ->
+    {ok, [V], []} = io_lib:fread("~16u", [X,Y]),
+    hex_to_bin(T, [V | Acc]).
+
+
+
+%%% Generatorators
+
+gen_case() ->
+    Ops = [amount, approx, read],
+    Op = lists:nth(rand:uniform(length(Ops)), Ops),
+    gen_case(Op).
+
+gen_case(read) ->
+    Pucks = random_pucks(12),
+    Style = random_style(),
+    {read, hz_format:amount(gaju, Style, Pucks), Pucks};
+gen_case(amount) ->
+    Unit = random_unit(),
+    Pucks =
+        case Unit of
+            gaju -> random_pucks(12);
+            puck -> random_pucks(8)
+        end,
+    Style = random_style(),
+    Sep = lists:nth(rand:uniform(2), [$,, $_]),
+    Span = rand:uniform(4),
+    Amount = hz_format:amount(Unit, hz_style(Style, Sep, Span), Pucks),
+    {amount, Style, Unit, Sep, Span, Pucks, Amount};
+gen_case(approx) ->
+    Pucks = random_pucks(12),
+    Sep = lists:nth(rand:uniform(2), [$,, $_]),
+    Span = rand:uniform(2) + 2,
+    Prec = rand:uniform(18),
+    Approx = hz_format:approx_amount({Sep, Span}, Prec, Pucks),
+    {approx, us, gaju, Sep, Span, Pucks, Prec, Approx}.
+
+random_pucks(MaxBytes) ->
+    Bytes = rand:bytes(rand:uniform(MaxBytes)),
+    crypto:bytes_to_integer(Bytes).
+
+random_style() ->
+    lists:nth(rand:uniform(4), [us, jp, metric, legacy]).
+
+random_unit() ->
+    lists:nth(rand:uniform(2), [gaju, puck]).
+
+hz_style(us, Sep, Span) -> {Sep, Span};
+hz_style(Style, _, _)   -> Style.
+
+serialize_case({amount, Style, Unit, Sep, Span, Pucks, _}) ->
+    FStyle = string:uppercase(atom_to_list(Style)),
+    FUnit = string:uppercase(atom_to_list(Unit)),
+    Stuff = [FStyle, FUnit, Sep, Span, Pucks],
+    io_lib:format("amount|~ts|~ts|~c|~b|~b", Stuff);
+serialize_case({approx, Style, Unit, Sep, Span, Pucks, Prec, _}) ->
+    FStyle = string:uppercase(atom_to_list(Style)),
+    FUnit = string:uppercase(atom_to_list(Unit)),
+    Stuff = [FStyle, FUnit, Sep, Span, Pucks, Prec],
+    io_lib:format("approx|~ts|~ts|~c|~b|~b|~b", Stuff);
+serialize_case({read, Input, _}) ->
+    InputStr = unicode:characters_to_list(Input),
+    io_lib:format("read|~ts", [InputStr]).
+
+compare_results([], []) ->
+    true;
+compare_results([Case | Cases], [Result | Results]) ->
+    case check_case(Case, Result) of
+        true ->
+            compare_results(Cases, Results);
+        false ->
+            io:format("Parity failure!~nCase: ~tp~nJava Result: ~tp~n", [Case, Result]),
+            false
+    end.
+
+check_case({amount, _, _, _, _, _, Expected}, Result) ->
+    flatten(Expected) =:= flatten(Result);
+check_case({approx, _, _, _, _, _, _, Expected}, Result) ->
+    flatten(Expected) =:= flatten(Result);
+check_case({read, _, Expected}, Result) ->
+    integer_to_list(Expected) =:= flatten(Result).
+
+flatten(B) when is_binary(B) -> unicode:characters_to_list(B);
+flatten(L) when is_list(L)   -> unicode:characters_to_list(L).
@@ -6,7 +6,8 @@
 {author,"Craig Everett"}.
 {desc,"An inter-language test suite for Gajumaru core libs"}.
 {package_id,{"qpq","gm_libtester",{0,1,0}}}.
-{deps,[{"otpr","hakuzaru",{0,9,1}},
+{deps,[{"otpr","sha3",{0,1,4}},
+       {"otpr","hakuzaru",{0,9,1}},
       {"otpr","getopt",{1,0,2}},
       {"otpr","zj",{1,1,0}},
       {"otpr","ec_utils",{1,0,0}},