refactor(ancestors): make maxSlot return optional and add insert assertion

- Change maxSlot() to return ?Slot instead of Slot, returning null for empty ancestors
- Add assertion in addAncestorWithoutCapacityCheck to ensure slots are inserted in order
- Update all call sites in epoch_tracker tests to unwrap the optional

Author: yewman

src/core/ancestors.zig

@@ -52,6 +52,8 @@ pub const Ancestors = struct {
         self: *Ancestors,
         slot: Slot,
     ) void {
+        const keys = self.ancestors.keys();
+        std.debug.assert(keys.len == 0 or slot > keys[keys.len - 1]);
         self.ancestors.putAssumeCapacity(slot, {});
     }
 
@@ -72,12 +74,10 @@ pub const Ancestors = struct {
         return .{ .ancestors = try self.ancestors.clone(allocator) };
     }
 
-    pub fn maxSlot(self: *const Ancestors) Slot {
-        var max_slot: Slot = 0;
-        for (self.ancestors.keys()) |slot| {
-            if (slot > max_slot) max_slot = slot;
-        }
-        return max_slot;
+    pub fn maxSlot(self: *const Ancestors) ?Slot {
+        const keys = self.ancestors.keys();
+        if (keys.len == 0) return null;
+        return keys[keys.len - 1];
     }
 
     pub fn subsetInto(

src/core/epoch_tracker.zig

@@ -784,7 +784,7 @@ test EpochTracker {
 
         _ = try epoch_tracker.insertUnrootedEpochInfo(
             allocator,
-            branch.maxSlot(),
+            branch.maxSlot().?,
             &branch,
             try sig.core.stakes.randomEpochStakes(
                 allocator,
@@ -794,7 +794,7 @@ test EpochTracker {
             &.ALL_DISABLED,
         );
 
-        try epoch_tracker.onSlotRooted(allocator, branch.maxSlot(), &branch);
+        try epoch_tracker.onSlotRooted(allocator, branch.maxSlot().?, &branch);
     }
 
     // Check that the root slot is 9 * 32 and epochs 6, 7, 8, 9 are available
@@ -815,10 +815,10 @@ test EpochTracker {
     // Check that trying to insert epoch info for epoch 9 fails because it is already rooted
     const branch = try Ancestors.initWithSlots(allocator, &.{319});
     defer branch.deinit(allocator);
-    fail_stakes.stakes.epoch = epoch_schedule.getEpoch(branch.maxSlot());
+    fail_stakes.stakes.epoch = epoch_schedule.getEpoch(branch.maxSlot().?);
     try std.testing.expectError(error.InvalidInsert, epoch_tracker.insertUnrootedEpochInfo(
         allocator,
-        branch.maxSlot(),
+        branch.maxSlot().?,
         &branch,
         fail_stakes,
         &.ALL_DISABLED,
@@ -845,12 +845,12 @@ test EpochTracker {
     defer allocator.free(insert_ptrs);
     for (0..4) |i| insert_ptrs[i] = try epoch_tracker.insertUnrootedEpochInfo(
         allocator,
-        branches[i].maxSlot(),
+        branches[i].maxSlot().?,
         &branches[i],
         try sig.core.stakes.randomEpochStakes(
             allocator,
             random,
-            .{ .epoch = epoch_schedule.getEpoch(branches[i].maxSlot()) },
+            .{ .epoch = epoch_schedule.getEpoch(branches[i].maxSlot().?) },
         ),
         &.ALL_DISABLED,
     );
@@ -862,31 +862,31 @@ test EpochTracker {
     );
 
     // Check that another insert hits max forks
-    fail_stakes.stakes.epoch = epoch_schedule.getEpoch(branches[4].maxSlot());
+    fail_stakes.stakes.epoch = epoch_schedule.getEpoch(branches[4].maxSlot().?);
     try std.testing.expectError(error.MaxForksExceeded, epoch_tracker.insertUnrootedEpochInfo(
         allocator,
-        branches[4].maxSlot(),
+        branches[4].maxSlot().?,
         &branches[4],
         fail_stakes,
         &.ALL_DISABLED,
     ));
 
     // Root the first slot from branch 2
-    try epoch_tracker.onSlotRooted(allocator, branches[2].maxSlot(), &branches[2]);
+    try epoch_tracker.onSlotRooted(allocator, branches[2].maxSlot().?, &branches[2]);
 
     // Check that the pointers returned from insert match the pointers returned from get
     for (0..4) |i| try std.testing.expectEqual(
         insert_ptrs[i],
         if (i != 2)
             try epoch_tracker.unrooted_epochs.get(&branches[i])
         else
-            try epoch_tracker.rooted_epochs.get(epoch_schedule.getEpoch(branches[i].maxSlot())),
+            try epoch_tracker.rooted_epochs.get(epoch_schedule.getEpoch(branches[i].maxSlot().?)),
     );
 
     // Check we can't insert unrooted if the epoch is already rooted
     try std.testing.expectError(error.InvalidInsert, epoch_tracker.insertUnrootedEpochInfo(
         allocator,
-        branches[4].maxSlot(),
+        branches[4].maxSlot().?,
         &branches[4],
         fail_stakes,
         &.ALL_DISABLED,