refactor(fork-choice): use in-place init for ProtoArray and ForkChoiceStore

- ProtoArray.init/initialize now take self: *ProtoArray and write self.*
  directly, avoiding stack-to-heap copy for heap-allocated instances
- ForkChoiceStore.init now takes self: *ForkChoiceStore, matching the
  existing ForkChoice.init pattern
- ProtoArray.init demoted to private (fn) since it's only called from
  initialize internally
- Fix missing allocator arg in ForkChoiceStore.deinit test calls

Author: GrapeBaBa

bench/fork_choice/util.zig

@@ -95,13 +95,13 @@ pub fn initializeForkChoice(allocator: Allocator, opts: Opts) !*ForkChoice {
     // -- ProtoArray from genesis --
     const pa = try allocator.create(ProtoArray);
     errdefer allocator.destroy(pa);
-    pa.* = try ProtoArray.initialize(allocator, genesis_block, 0);
+    try pa.initialize(allocator, genesis_block, 0);
     errdefer pa.deinit(allocator);
 
     // -- ForkChoiceStore --
     const fc_store = try allocator.create(ForkChoiceStore);
     errdefer allocator.destroy(fc_store);
-    fc_store.* = try ForkChoiceStore.init(
+    try fc_store.init(
         allocator,
         0,
         genesis_cp,

src/fork_choice/fork_choice.zig

@@ -2152,7 +2152,7 @@ fn initTestForkChoice(
     const pa = try allocator.create(ProtoArray);
     errdefer allocator.destroy(pa);
 
-    pa.* = try ProtoArray.initialize(
+    try pa.initialize(
         allocator,
         anchor_block,
         current_slot,
@@ -2162,7 +2162,7 @@ fn initTestForkChoice(
     const fc_store = try allocator.create(ForkChoiceStore);
     errdefer allocator.destroy(fc_store);
 
-    fc_store.* = try ForkChoiceStore.init(
+    try fc_store.init(
         allocator,
         current_slot,
         justified_checkpoint,
@@ -2206,7 +2206,7 @@ fn initTestForkChoiceWithOpts(
 ) !*ForkChoice {
     const pa = try allocator.create(ProtoArray);
     errdefer allocator.destroy(pa);
-    pa.* = try ProtoArray.initialize(allocator, anchor_block, current_slot);
+    try pa.initialize(allocator, anchor_block, current_slot);
     errdefer pa.deinit(allocator);
 
     const fc_store = try allocator.create(ForkChoiceStore);

src/fork_choice/proto_array.zig

@@ -533,14 +533,15 @@ pub const ProtoArray = struct {
         score: u64,
     };
 
-    pub fn init(
+    fn init(
+        self: *ProtoArray,
         justified_epoch: Epoch,
         justified_root: Root,
         finalized_epoch: Epoch,
         finalized_root: Root,
         prune_threshold: u32,
-    ) ProtoArray {
-        return .{
+    ) void {
+        self.* = .{
             .nodes = .empty,
             .indices = .empty,
             .prune_threshold = prune_threshold,
@@ -564,26 +565,25 @@ pub const ProtoArray = struct {
     /// Create a ProtoArray from a genesis/anchor block.
     /// The block's block_root is used as its target_root since it lies on an epoch boundary.
     pub fn initialize(
+        self: *ProtoArray,
         allocator: Allocator,
         block: ProtoBlock,
         current_slot: Slot,
-    ) (Allocator.Error || ProtoArrayError)!ProtoArray {
-        var proto_array = ProtoArray.init(
+    ) (Allocator.Error || ProtoArrayError)!void {
+        self.init(
             block.justified_epoch,
             block.justified_root,
             block.finalized_epoch,
             block.finalized_root,
             DEFAULT_PRUNE_THRESHOLD,
         );
-        errdefer proto_array.deinit(allocator);
+        errdefer self.deinit(allocator);
 
         // Use block_root as target_root — genesis/anchor always sits on an epoch boundary.
         var anchor = block;
         anchor.target_root = block.block_root;
 
-        try proto_array.onBlock(allocator, anchor, current_slot, null);
-
-        return proto_array;
+        try self.onBlock(allocator, anchor, current_slot, null);
     }
 
     // ── Accessors ──
@@ -2327,7 +2327,8 @@ fn makeRoot(byte: u8) Root {
 
 // Tree: (empty — no blocks inserted)
 test "init and deinit" {
-    var pa = ProtoArray.init(1, ZERO_HASH, 0, ZERO_HASH, 0);
+    var pa: ProtoArray = undefined;
+    pa.init(1, ZERO_HASH, 0, ZERO_HASH, 0);
     defer pa.deinit(testing.allocator);
 
     try testing.expectEqual(@as(usize, 0), pa.nodes.items.len);

src/fork_choice/store.zig

@@ -129,14 +129,15 @@ pub const ForkChoiceStore = struct {
     };
 
     pub fn init(
+        self: *ForkChoiceStore,
         allocator: Allocator,
         current_slot: Slot,
         justified_checkpoint: CheckpointWithPayloadStatus,
         finalized_checkpoint: CheckpointWithPayloadStatus,
         justified_balances: []const u16,
         justified_balances_getter: JustifiedBalancesGetter,
         events: ForkChoiceStoreEvents,
-    ) !ForkChoiceStore {
+    ) !void {
         var balances_list = JustifiedBalances.init(allocator);
         errdefer balances_list.deinit();
 
@@ -150,7 +151,7 @@ pub const ForkChoiceStore = struct {
         // referenced by `unrealized_justified`
         _ = balances_rc.acquire();
 
-        return .{
+        self.* = .{
             .current_slot = current_slot,
             .justified = .{
                 .checkpoint = justified_checkpoint,
@@ -227,7 +228,8 @@ fn dummyBalancesGetter(_: ?*anyopaque, _: CheckpointWithPayloadStatus, _: *Cache
 const test_getter: JustifiedBalancesGetter = .{ .getFn = dummyBalancesGetter };
 
 fn initTestStore(balances: []const u16) !ForkChoiceStore {
-    return ForkChoiceStore.init(
+    var store: ForkChoiceStore = undefined;
+    try store.init(
         testing.allocator,
         0,
         makeCheckpoint(0, hashFromByte(0x01)),
@@ -236,6 +238,7 @@ fn initTestStore(balances: []const u16) !ForkChoiceStore {
         test_getter,
         .{},
     );
+    return store;
 }
 
 test "computeTotalBalance" {
@@ -270,7 +273,7 @@ test "CheckpointWithPayloadStatus.fromCheckpoint" {
 
 test "init shares Rc between justified and unrealized_justified" {
     var store = try initTestStore(&.{ 10, 20, 30 });
-    defer store.deinit();
+    defer store.deinit(testing.allocator);
 
     // Both point to the same Rc (ref_count = 2).
     try testing.expectEqual(store.justified.balances, store.unrealized_justified.balances);
@@ -283,7 +286,7 @@ test "init shares Rc between justified and unrealized_justified" {
 
 test "setJustified separates Rc from unrealized_justified" {
     var store = try initTestStore(&.{ 10, 20 });
-    defer store.deinit();
+    defer store.deinit(testing.allocator);
 
     const old_rc = store.justified.balances;
     const new_cp = makeCheckpoint(1, hashFromByte(0x02));
@@ -322,7 +325,7 @@ test "setFinalizedCheckpoint updates and fires event" {
         test_getter,
         .{ .on_finalized = .{ .context = @ptrCast(&tracker), .callFn = Tracker.onFinalized } },
     );
-    defer store.deinit();
+    defer store.deinit(testing.allocator);
 
     const new_cp = makeCheckpoint(3, hashFromByte(0x0F));
     store.setFinalizedCheckpoint(new_cp);
@@ -354,7 +357,7 @@ test "setJustified fires onJustified event" {
         test_getter,
         .{ .on_justified = .{ .context = @ptrCast(&tracker), .callFn = Tracker.onJustified } },
     );
-    defer store.deinit();
+    defer store.deinit(testing.allocator);
 
     try store.setJustified(testing.allocator, makeCheckpoint(2, hashFromByte(0x0A)), &.{ 7, 8 });
 
@@ -365,5 +368,5 @@ test "setJustified fires onJustified event" {
 test "deinit releases all Rc without leak" {
     // If deinit leaks, testing.allocator will report it.
     var store = try initTestStore(&.{ 1, 2, 3 });
-    store.deinit();
+    store.deinit(testing.allocator);
 }