Switch SSZ hashing to Poseidon2 via hash‑zig (BREAKING)

build.zig

@@ -88,6 +88,10 @@ pub fn build(b: *Builder) !void {
         .target = target,
         .optimize = optimize,
     }).module("ssz.zig");
+    const hash_zig = b.dependency("hash-zig", .{
+        .target = target,
+        .optimize = optimize,
+    }).module("hash-zig");
     const simargs = b.dependency("zigcli", .{
         .target = target,
         .optimize = optimize,
@@ -179,6 +183,7 @@ pub fn build(b: *Builder) !void {
         .optimize = optimize,
     });
     zeam_types.addImport("ssz", ssz);
+    zeam_types.addImport("hash-zig", hash_zig);
     zeam_types.addImport("@zeam/params", zeam_params);
     zeam_types.addImport("@zeam/utils", zeam_utils);
     zeam_types.addImport("@zeam/metrics", zeam_metrics);
@@ -221,6 +226,7 @@ pub fn build(b: *Builder) !void {
     zeam_key_manager.addImport("@zeam/types", zeam_types);
     zeam_key_manager.addImport("@zeam/metrics", zeam_metrics);
     zeam_key_manager.addImport("ssz", ssz);
+    zeam_key_manager.addImport("hash-zig", hash_zig);
 
     // add zeam-state-transition
     const zeam_state_transition = b.addModule("@zeam/state-transition", .{
@@ -232,6 +238,7 @@ pub fn build(b: *Builder) !void {
     zeam_state_transition.addImport("@zeam/params", zeam_params);
     zeam_state_transition.addImport("@zeam/types", zeam_types);
     zeam_state_transition.addImport("ssz", ssz);
+    zeam_state_transition.addImport("hash-zig", hash_zig);
     zeam_state_transition.addImport("@zeam/api", zeam_api);
     zeam_state_transition.addImport("@zeam/xmss", zeam_xmss);
     zeam_state_transition.addImport("@zeam/key-manager", zeam_key_manager);
@@ -291,6 +298,7 @@ pub fn build(b: *Builder) !void {
     });
     zeam_beam_node.addImport("xev", xev);
     zeam_beam_node.addImport("ssz", ssz);
+    zeam_beam_node.addImport("hash-zig", hash_zig);
     zeam_beam_node.addImport("@zeam/utils", zeam_utils);
     zeam_beam_node.addImport("@zeam/params", zeam_params);
     zeam_beam_node.addImport("@zeam/types", zeam_types);
@@ -313,6 +321,7 @@ pub fn build(b: *Builder) !void {
     zeam_spectests.addImport("@zeam/params", zeam_params);
     zeam_spectests.addImport("@zeam/key-manager", zeam_key_manager);
     zeam_spectests.addImport("ssz", ssz);
+    zeam_spectests.addImport("hash-zig", hash_zig);
     zeam_spectests.addImport("build_options", build_options_module);
     zeam_spectests.addImport("@zeam/state-transition", zeam_state_transition);
     zeam_spectests.addImport("@zeam/node", zeam_beam_node);
@@ -334,6 +343,7 @@ pub fn build(b: *Builder) !void {
 
     // addimport to root module is even required afer declaring it in mod
     cli_exe.root_module.addImport("ssz", ssz);
+    cli_exe.root_module.addImport("hash-zig", hash_zig);
     cli_exe.root_module.addImport("build_options", build_options_module);
     cli_exe.root_module.addImport("simargs", simargs);
     cli_exe.root_module.addImport("xev", xev);
@@ -562,6 +572,7 @@ pub fn build(b: *Builder) !void {
     xmss_cycle_tests.root_module.addImport("@zeam/key-manager", zeam_key_manager);
     xmss_cycle_tests.root_module.addImport("@zeam/types", zeam_types);
     xmss_cycle_tests.root_module.addImport("ssz", ssz);
+    xmss_cycle_tests.root_module.addImport("hash-zig", hash_zig);
     xmss_cycle_tests.step.dependOn(&build_rust_lib_steps.step);
     addRustGlueLib(b, xmss_cycle_tests, target, prover);
     const run_xmss_cycle_tests = b.addRunArtifact(xmss_cycle_tests);
@@ -578,6 +589,7 @@ pub fn build(b: *Builder) !void {
     spectests.root_module.addImport("@zeam/metrics", zeam_metrics);
     spectests.root_module.addImport("@zeam/state-transition", zeam_state_transition);
     spectests.root_module.addImport("ssz", ssz);
+    spectests.root_module.addImport("hash-zig", hash_zig);
 
     manager_tests.step.dependOn(&build_rust_lib_steps.step);
 
@@ -717,6 +729,11 @@ fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Bui
             .optimize = optimize,
         }).module("ssz.zig");
 
+        const hash_zig = b.dependency("hash-zig", .{
+            .target = target,
+            .optimize = optimize,
+        }).module("hash-zig");
+
         // add metrics
         const metrics = b.dependency("metrics", .{
             .target = target,
@@ -752,6 +769,7 @@ fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Bui
             .root_source_file = b.path("pkgs/types/src/lib.zig"),
         });
         zeam_types.addImport("ssz", ssz);
+        zeam_types.addImport("hash-zig", hash_zig);
         zeam_types.addImport("@zeam/params", zeam_params);
         zeam_types.addImport("@zeam/utils", zeam_utils);
         zeam_types.addImport("@zeam/metrics", zeam_metrics);
@@ -774,6 +792,7 @@ fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Bui
         zeam_state_transition.addImport("@zeam/params", zeam_params);
         zeam_state_transition.addImport("@zeam/types", zeam_types);
         zeam_state_transition.addImport("ssz", ssz);
+        zeam_state_transition.addImport("hash-zig", hash_zig);
         zeam_state_transition.addImport("@zeam/metrics", zeam_metrics);
         zeam_state_transition.addImport("zkvm", zkvm_module);
 

pkgs/cli/src/node.zig

@@ -1,4 +1,6 @@
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const enr_lib = @import("enr");
 const ENR = enr_lib.ENR;
 const utils_lib = @import("@zeam/utils");
@@ -1016,7 +1018,7 @@ test "compare roots from genGensisBlock and genGenesisState and genStateBlockHea
 
     // Get state root by hashing the state directly
     var state_root_from_genesis: [32]u8 = undefined;
-    try ssz.hashTreeRoot(types.BeamState, genesis_state, &state_root_from_genesis, allocator);
+    try ssz.hashTreeRoot(PoseidonHasher, types.BeamState, genesis_state, &state_root_from_genesis, allocator);
 
     // Generate block header using genStateBlockHeader
     const state_block_header = try genesis_state.genStateBlockHeader(allocator);
@@ -1029,7 +1031,7 @@ test "compare roots from genGensisBlock and genGenesisState and genStateBlockHea
     // Verify the state root matches the expected value
     const state_root_from_genesis_hex = try std.fmt.allocPrint(allocator, "0x{s}", .{std.fmt.fmtSliceHexLower(&state_root_from_genesis)});
     defer allocator.free(state_root_from_genesis_hex);
-    try std.testing.expectEqualStrings(state_root_from_genesis_hex, "0xdda67dde8a468b0087881f6d8f1cd159ca4c2e82f780156744dc920049515cb1");
+    try std.testing.expectEqualStrings(state_root_from_genesis_hex, "0x04b1dc0d74c0427247f31338a19aa7401e0ff01de31ea06defeaeb744dde3e32");
 }
 
 test "populateNodeNameRegistry" {

pkgs/key-manager/src/lib.zig

@@ -3,6 +3,8 @@ const xmss = @import("@zeam/xmss");
 const types = @import("@zeam/types");
 const zeam_metrics = @import("@zeam/metrics");
 const ssz = @import("ssz");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 
 const KeyManagerError = error{
@@ -97,7 +99,7 @@ pub const KeyManager = struct {
 
         const signing_timer = zeam_metrics.lean_pq_signature_attestation_signing_time_seconds.start();
         var message: [32]u8 = undefined;
-        try ssz.hashTreeRoot(types.Attestation, attestation.*, &message, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.Attestation, attestation.*, &message, allocator);
 
         const epoch: u32 = @intCast(attestation.data.slot);
 

pkgs/node/src/chain.zig

@@ -1,4 +1,6 @@
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 const json = std.json;
 
@@ -293,7 +295,7 @@ pub const BeamChain = struct {
 
         // 3. cache state to save recompute while adding the block on publish
         var block_root: [32]u8 = undefined;
-        try ssz.hashTreeRoot(types.BeamBlock, block, &block_root, self.allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &block_root, self.allocator);
         try self.states.put(block_root, post_state);
 
         // 4. Add the block to directly forkchoice as this proposer will next need to construct its vote
@@ -425,7 +427,7 @@ pub const BeamChain = struct {
             .block => |signed_block| {
                 const block = signed_block.message.block;
                 var block_root: [32]u8 = undefined;
-                try ssz.hashTreeRoot(types.BeamBlock, block, &block_root, self.allocator);
+                try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &block_root, self.allocator);
 
                 //check if we have the block already in forkchoice
                 const hasBlock = self.forkChoice.hasBlock(block_root);
@@ -527,7 +529,7 @@ pub const BeamChain = struct {
 
         const block_root: types.Root = blockInfo.blockRoot orelse computedroot: {
             var cblock_root: [32]u8 = undefined;
-            try ssz.hashTreeRoot(types.BeamBlock, block, &cblock_root, self.allocator);
+            try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &cblock_root, self.allocator);
             break :computedroot cblock_root;
         };
 
@@ -1089,7 +1091,7 @@ test "process and add mock blocks into a node's chain" {
         // should have matching states in the state
         const block_state = beam_chain.states.get(block_root) orelse @panic("state root should have been found");
         var state_root: [32]u8 = undefined;
-        try ssz.hashTreeRoot(*types.BeamState, block_state, &state_root, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, *types.BeamState, block_state, &state_root, allocator);
         try std.testing.expect(std.mem.eql(u8, &state_root, &block.state_root));
 
         // fcstore checkpoints should match

pkgs/node/src/forkchoice.zig

@@ -1,5 +1,7 @@
 const std = @import("std");
 const json = std.json;
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 
 const ssz = @import("ssz");
@@ -226,6 +228,7 @@ pub const ForkChoice = struct {
         const anchor_block_header = try opts.anchorState.genStateBlockHeader(allocator);
         var anchor_block_root: [32]u8 = undefined;
         try ssz.hashTreeRoot(
+            PoseidonHasher,
             types.BeamBlockHeader,
             anchor_block_header,
             &anchor_block_root,
@@ -804,7 +807,7 @@ pub const ForkChoice = struct {
 
             const block_root: [32]u8 = opts.blockRoot orelse computedroot: {
                 var cblock_root: [32]u8 = undefined;
-                try ssz.hashTreeRoot(types.BeamBlock, block, &cblock_root, self.allocator);
+                try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &cblock_root, self.allocator);
                 break :computedroot cblock_root;
             };
             const is_timely = self.isBlockTimely(opts.blockDelayMs);

pkgs/node/src/node.zig

@@ -1,4 +1,6 @@
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 
 pub const database = @import("@zeam/database");
@@ -136,7 +138,7 @@ pub const BeamNode = struct {
                 }
 
                 var block_root: types.Root = undefined;
-                if (ssz.hashTreeRoot(types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
+                if (ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
                     _ = self.network.removePendingBlockRoot(block_root);
                 } else |err| {
                     self.logger.warn("failed to compute block root for incoming gossip block: {any}", .{err});
@@ -165,7 +167,7 @@ pub const BeamNode = struct {
                 if (data.* == .block) {
                     const signed_block = data.block;
                     var block_root: types.Root = undefined;
-                    if (ssz.hashTreeRoot(types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
+                    if (ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
                         self.logger.info(
                             "gossip block 0x{s} rejected as pre-finalized; pruning cached descendants",
                             .{std.fmt.fmtSliceHexLower(block_root[0..])},
@@ -347,7 +349,7 @@ pub const BeamNode = struct {
 
     fn processBlockByRootChunk(self: *Self, block_ctx: *const BlockByRootContext, signed_block: *const types.SignedBlockWithAttestation) !void {
         var block_root: types.Root = undefined;
-        if (ssz.hashTreeRoot(types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
+        if (ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, signed_block.message.block, &block_root, self.allocator)) |_| {
             const current_depth = self.network.getPendingBlockRootDepth(block_root) orelse 0;
             const removed = self.network.removePendingBlockRoot(block_root);
             if (!removed) {
@@ -759,7 +761,7 @@ pub const BeamNode = struct {
 
         // 1. Process locally through chain so that produced block first can be confirmed
         var block_root: [32]u8 = undefined;
-        try ssz.hashTreeRoot(types.BeamBlock, signed_block.message.block, &block_root, self.allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, signed_block.message.block, &block_root, self.allocator);
 
         // check if the block has not already been received through the network
         const hasBlock = self.chain.forkChoice.hasBlock(block_root);

pkgs/spectest/src/runner/fork_choice_runner.zig

@@ -1,4 +1,6 @@
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const json = std.json;
 const Allocator = std.mem.Allocator;
 
@@ -291,7 +293,7 @@ fn runCase(
     defer label_map.deinit(allocator);
 
     var anchor_root: types.Root = undefined;
-    ssz.hashTreeRoot(types.BeamBlock, anchor_block, &anchor_root, allocator) catch |err| {
+    ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, anchor_block, &anchor_root, allocator) catch |err| {
         std.debug.print(
             "fixture {s} case {s}: anchor block hashing failed ({s})\n",
             .{ ctx.fixture_label, ctx.case_name, @errorName(err) },
@@ -607,7 +609,7 @@ fn processBlockStep(
     defer block.deinit();
 
     var block_root: types.Root = undefined;
-    ssz.hashTreeRoot(types.BeamBlock, block, &block_root, ctx.allocator) catch |err| {
+    ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &block_root, ctx.allocator) catch |err| {
         std.debug.print(
             "fixture {s} case {s}{}: hashing block failed ({s})\n",
             .{ fixture_path, case_name, formatStep(step_index), @errorName(err) },

pkgs/spectest/src/runner/state_transition_runner.zig

@@ -1,4 +1,6 @@
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 
 const expect = @import("../json_expect.zig");
 const forks = @import("../fork.zig");
@@ -245,7 +247,7 @@ fn runCase(
             var header_for_check = pre_state.latest_block_header;
             if (std.mem.eql(u8, &header_for_check.state_root, &types.ZERO_HASH)) {
                 var pre_state_root: types.Root = undefined;
-                ssz.hashTreeRoot(types.BeamState, pre_state, &pre_state_root, allocator) catch |err| {
+                ssz.hashTreeRoot(PoseidonHasher, types.BeamState, pre_state, &pre_state_root, allocator) catch |err| {
                     std.debug.print(
                         "fixture {s} case {s}: unable to hash pre-state ({s})\n",
                         .{ ctx.fixture_label, ctx.case_name, @errorName(err) },
@@ -256,7 +258,7 @@ fn runCase(
             }
 
             var header_root: types.Root = undefined;
-            ssz.hashTreeRoot(types.BeamBlockHeader, header_for_check, &header_root, allocator) catch |err| {
+            ssz.hashTreeRoot(PoseidonHasher, types.BeamBlockHeader, header_for_check, &header_root, allocator) catch |err| {
                 std.debug.print(
                     "fixture {s} case {s}: unable to hash latest block header ({s})\n",
                     .{ ctx.fixture_label, ctx.case_name, @errorName(err) },

pkgs/state-transition/src/lib.zig

@@ -1,5 +1,7 @@
 const ssz = @import("ssz");
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 
 const types = @import("@zeam/types");
@@ -55,7 +57,7 @@ test "apply transition on mocked chain" {
     // check the post state root to be equal to block2's stateroot
     // this is reduant though because apply_transition already checks this for each block's state root
     var post_state_root: [32]u8 = undefined;
-    try ssz.hashTreeRoot(types.BeamState, beam_state, &post_state_root, allocator);
+    try ssz.hashTreeRoot(PoseidonHasher, types.BeamState, beam_state, &post_state_root, allocator);
     try std.testing.expect(std.mem.eql(u8, &post_state_root, &mock_chain.blocks[mock_chain.blocks.len - 1].message.block.state_root));
 }
 
@@ -73,11 +75,11 @@ test "genStateBlockHeader" {
         // get applied block
         const applied_block = mock_chain.blocks[i];
         var applied_block_root: types.Root = undefined;
-        try ssz.hashTreeRoot(types.BeamBlock, applied_block.message.block, &applied_block_root, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, applied_block.message.block, &applied_block_root, allocator);
 
         const state_block_header = try beam_state.genStateBlockHeader(allocator);
         var state_block_header_root: types.Root = undefined;
-        try ssz.hashTreeRoot(types.BeamBlockHeader, state_block_header, &state_block_header_root, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlockHeader, state_block_header, &state_block_header_root, allocator);
 
         try std.testing.expect(std.mem.eql(u8, &applied_block_root, &state_block_header_root));
 

pkgs/state-transition/src/mock.zig

@@ -1,5 +1,7 @@
 const ssz = @import("ssz");
 const std = @import("std");
+const hash_zig = @import("hash-zig");
+const PoseidonHasher = hash_zig.ssz.SszHasher;
 const Allocator = std.mem.Allocator;
 
 const params = @import("@zeam/params");
@@ -114,7 +116,7 @@ pub fn genMockChain(allocator: Allocator, numBlocks: usize, from_genesis: ?types
         },
     };
     var block_root: types.Root = undefined;
-    try ssz.hashTreeRoot(types.BeamBlock, genesis_block, &block_root, allocator);
+    try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, genesis_block, &block_root, allocator);
 
     try blockList.append(gen_signed_block);
     try blockRootList.append(block_root);
@@ -144,7 +146,7 @@ pub fn genMockChain(allocator: Allocator, numBlocks: usize, from_genesis: ?types
 
     for (1..numBlocks) |slot| {
         var parent_root: [32]u8 = undefined;
-        try ssz.hashTreeRoot(types.BeamBlock, prev_block, &parent_root, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, prev_block, &parent_root, allocator);
 
         const state_root: [32]u8 = types.ZERO_HASH;
         // const timestamp = genesis_config.genesis_time + slot * params.SECONDS_PER_SLOT;
@@ -296,7 +298,7 @@ pub fn genMockChain(allocator: Allocator, numBlocks: usize, from_genesis: ?types
 
         // prepare pre state to process block for that slot, may be rename prepare_pre_state
         try transition.apply_raw_block(allocator, &beam_state, &block, block_building_logger);
-        try ssz.hashTreeRoot(types.BeamBlock, block, &block_root, allocator);
+        try ssz.hashTreeRoot(PoseidonHasher, types.BeamBlock, block, &block_root, allocator);
 
         // generate the signed beam block and add to block list
         const block_with_attestation = types.BlockWithAttestation{