Add feature_set to EpochInfo

Author: InKryption

src/cmd.zig

@@ -2902,30 +2902,30 @@ fn loggingPanic(message: []const u8, first_trace_addr: ?usize) noreturn {
     std.debug.defaultPanic(message, first_trace_addr);
 }
 
-pub const RpcLeaderScheduleService = struct {
+/// NOTE: This only populates the leader schedule, and leaves the epoch stake & features empty (ie ALL_DISABLED).
+const RpcLeaderScheduleService = struct {
     allocator: std.mem.Allocator,
     logger: RpcLeaderScheduleServiceLogger,
     rpc_client: sig.rpc.Client,
     epoch_tracker: *sig.core.EpochTracker,
 
-    const Self = @This();
-    const RpcLeaderScheduleServiceLogger = sig.trace.Logger(@typeName(Self));
+    const RpcLeaderScheduleServiceLogger = sig.trace.Logger(@typeName(RpcLeaderScheduleService));
 
-    pub fn init(
+    fn init(
         allocator: std.mem.Allocator,
         logger: RpcLeaderScheduleServiceLogger,
         epoch_tracker: *sig.core.EpochTracker,
         rpc_client: sig.rpc.Client,
-    ) Self {
+    ) RpcLeaderScheduleService {
         return .{
             .allocator = allocator,
-            .logger = logger.withScope(@typeName(Self)),
+            .logger = logger.withScope(@typeName(RpcLeaderScheduleService)),
             .rpc_client = rpc_client,
             .epoch_tracker = epoch_tracker,
         };
     }
 
-    pub fn run(self: *Self, exit: *std.atomic.Value(bool)) void {
+    fn run(self: *RpcLeaderScheduleService, exit: *std.atomic.Value(bool)) void {
         var i: usize = 0;
         while (!exit.load(.monotonic)) {
             if (i % 1000 == 0) {
@@ -2942,7 +2942,7 @@ pub const RpcLeaderScheduleService = struct {
         }
     }
 
-    fn refresh(self: *Self) !void {
+    fn refresh(self: *RpcLeaderScheduleService) !void {
         const response = try self.rpc_client.getSlot(.{});
         defer response.deinit();
         const slot = try response.result();
@@ -2969,10 +2969,13 @@ pub const RpcLeaderScheduleService = struct {
                     &self.epoch_tracker.epoch_schedule,
                 );
 
-                var entry = try self.allocator.create(sig.core.EpochInfo);
+                const entry = try self.allocator.create(sig.core.EpochInfo);
                 entry.* = .{
                     .leaders = leaders,
                     .stakes = .EMPTY,
+                    // TODO: if you need features here for whatever reason, you'll have to implement
+                    // some way to forward them from replay, or source them by some other means.
+                    .feature_set = .ALL_DISABLED,
                 };
                 entry.stakes.stakes.epoch = e;
                 errdefer {
@@ -2986,7 +2989,7 @@ pub const RpcLeaderScheduleService = struct {
     }
 
     fn getLeaderSchedule(
-        self: *Self,
+        self: *RpcLeaderScheduleService,
         slot: sig.core.Slot,
         epoch_schedule: *const sig.core.EpochSchedule,
     ) !LeaderSchedule {

src/core/epoch_tracker.zig

@@ -253,6 +253,7 @@ pub const EpochTracker = struct {
         epoch_info_ptr.* = .{
             .leaders = leaders,
             .stakes = epoch_stakes,
+            .feature_set = feature_set.*,
         };
 
         try self.rooted_epochs.insert(allocator, epoch_info_ptr);
@@ -287,6 +288,7 @@ pub const EpochTracker = struct {
             .{
                 .leaders = leaders,
                 .stakes = epoch_stakes,
+                .feature_set = feature_set.*,
             },
         );
     }
@@ -338,6 +340,7 @@ pub const EpochTracker = struct {
                     .end = 0,
                 },
                 .stakes = stakes,
+                .feature_set = .ALL_DISABLED,
             };
             errdefer epoch_info_ptr.deinit(allocator);
 
@@ -351,16 +354,22 @@ pub const EpochTracker = struct {
 pub const EpochInfo = struct {
     leaders: LeaderSchedule,
     stakes: EpochStakes,
+    feature_set: sig.core.FeatureSet,
 
     pub fn deinit(self: *const EpochInfo, allocator: Allocator) void {
         self.leaders.deinit(allocator);
         self.stakes.deinit(allocator);
     }
 
-    fn init(leaders: LeaderSchedule, stakes: EpochStakes) !EpochInfo {
+    fn init(
+        leaders: LeaderSchedule,
+        stakes: EpochStakes,
+        feature_set: sig.core.FeatureSet,
+    ) EpochInfo {
         return .{
             .leaders = leaders,
             .stakes = stakes,
+            .feature_set = feature_set,
         };
     }
 
@@ -383,7 +392,7 @@ pub const EpochInfo = struct {
         });
         errdefer leaders.deinit(allocator);
 
-        return .init(leaders, stakes);
+        return .init(leaders, stakes, .ALL_DISABLED);
     }
 };
 
@@ -647,13 +656,14 @@ test RootedEpochBuffer {
     }
     for (epoch - 2..epoch + 1, 0..) |epoch_i, i| {
         const info = try buffer.get(epoch_i);
-        expected[i] = EpochInfo{
+        expected[i] = .{
             .leaders = .{
                 .leaders = try allocator.dupe(Pubkey, info.leaders.leaders),
                 .start = info.leaders.start,
                 .end = info.leaders.end,
             },
             .stakes = try info.stakes.clone(allocator),
+            .feature_set = .ALL_DISABLED,
         };
     }