feat(rpc): implement getBalance RPC method

- Add getBalance handler with commitment level support in AccountsDB
- Add getSlotForCommitment to SlotTracker for commitment-based slot resolution
- Update registerRPCHooks signature to accept slot_tracker and snapshot_slot
- Use snapshot slot as fallback when no live slot tracker is available

Author: prestonsn

src/accountsdb/db.zig

@@ -8,6 +8,7 @@ const tracy = @import("tracy");
 
 const sysvar = sig.runtime.sysvar;
 const snapgen = sig.accounts_db.snapshot.data.generate;
+const methods = sig.rpc.methods;
 
 const Resolution = @import("../benchmarks.zig").Resolution;
 
@@ -2873,9 +2874,64 @@ pub const AccountsDB = struct {
         return slotSatisfiesMax(slot, max_slot) and slotSatisfiesMin(slot, min_slot);
     }
 
-    pub fn registerRPCHooks(self: *AccountsDB, rpc_hooks: *sig.rpc.Hooks) !void {
+    pub fn registerRPCHooks(
+        self: *AccountsDB,
+        rpc_hooks: *sig.rpc.Hooks,
+        slot_tracker: ?*const sig.replay.trackers.SlotTracker,
+        snapshot_slot: Slot,
+    ) !void {
         try rpc_hooks.set(self.allocator, struct {
             accountsdb: *AccountsDB,
+            slot_tracker: ?*const sig.replay.trackers.SlotTracker,
+            snapshot_slot: Slot,
+
+            pub fn getBalance(
+                this: @This(),
+                _: std.mem.Allocator,
+                params: methods.GetBalance,
+            ) !methods.GetBalance.Response {
+                const config = params.config orelse methods.common.CommitmentSlotConfig{};
+
+                const commitment = config.commitment orelse .finalized;
+                const commitment_slot: Slot = if (this.slot_tracker) |tracker|
+                    tracker.getSlotForCommitment(commitment)
+                else
+                    this.snapshot_slot;
+                const max_slot: ?Slot = if (commitment == .processed) null else commitment_slot;
+
+                // Check minContextSlot constraint.
+                if (config.minContextSlot) |min_slot| {
+                    if (commitment_slot < min_slot) {
+                        return error.RpcMinContextSlotNotMet;
+                    }
+                }
+
+                // Look up account
+                const result = this.accountsdb.getSlotAndAccountInSlotRangeWithReadLock(
+                    &params.pubkey,
+                    config.minContextSlot,
+                    max_slot,
+                ) catch return error.AccountsDbError;
+
+                const lamports: u64 = if (result) |r| blk: {
+                    const account, _, var account_lock = r;
+                    defer account_lock.unlock();
+
+                    break :blk switch (account) {
+                        .file => |aif| aif.account_info.lamports,
+                        .unrooted_map => |um| um.lamports,
+                    };
+                    // TODO: is defaulting to 0 the correct behavior here?
+                } else 0;
+
+                return .{
+                    .context = .{
+                        .slot = commitment_slot,
+                        .apiVersion = "2.0.15",
+                    },
+                    .value = lamports,
+                };
+            }
 
             pub fn getAccountInfo(
                 this: @This(),
@@ -3098,7 +3154,7 @@ pub const AccountsDB = struct {
 
                 return null;
             }
-        }{ .accountsdb = self });
+        }{ .accountsdb = self, .slot_tracker = slot_tracker, .snapshot_slot = snapshot_slot });
     }
 };
 

src/cmd.zig

@@ -1997,9 +1997,10 @@ fn mockRpcServer(allocator: std.mem.Allocator, cfg: config.Cmd) !void {
         defer manifest.deinit(allocator);
     }
 
+    const snapshot_slot = if (snap_files.incremental_info) |inc| inc.slot else snap_files.full.slot;
     var rpc_hooks = sig.rpc.Hooks{};
     defer rpc_hooks.deinit(allocator);
-    try accountsdb.registerRPCHooks(&rpc_hooks);
+    try accountsdb.registerRPCHooks(&rpc_hooks, null, snapshot_slot);
 
     var server_ctx = try sig.rpc.server.Context.init(.{
         .allocator = allocator,

src/replay/trackers.zig

@@ -10,6 +10,7 @@ const EpochSchedule = sig.core.EpochSchedule;
 const Slot = sig.core.Slot;
 const SlotConstants = sig.core.SlotConstants;
 const SlotState = sig.core.SlotState;
+const Commitment = sig.rpc.methods.common.Commitment;
 
 pub const ForkChoiceProcessedSlot = struct {
     slot: std.atomic.Value(Slot) = .init(0),
@@ -122,6 +123,14 @@ pub const SlotTracker = struct {
         return elem.toRef();
     }
 
+    pub fn getSlotForCommitment(self: *const SlotTracker, commitment: Commitment) Slot {
+        return switch (commitment) {
+            .processed => self.latest_processed_slot.get(),
+            .confirmed => self.latest_confirmed_slot.get(),
+            .finalized => self.root.load(.monotonic),
+        };
+    }
+
     pub const GetOrPutResult = struct {
         found_existing: bool,
         reference: Reference,

src/rpc/server/server.zig

@@ -285,7 +285,7 @@ test "serveSpawn getSnapshot" {
     var rpc_hooks = sig.rpc.Hooks{};
     defer rpc_hooks.deinit(accountsdb.allocator);
 
-    try accountsdb.registerRPCHooks(&rpc_hooks);
+    try accountsdb.registerRPCHooks(&rpc_hooks, null, 0);
 
     const sock_addr = std.net.Address.initIp4(.{ 0, 0, 0, 0 }, 0);
     var server_ctx = try Context.init(.{
@@ -440,7 +440,7 @@ test "serveSpawn getAccountInfo" {
 
     var rpc_hooks = sig.rpc.Hooks{};
     defer rpc_hooks.deinit(allocator);
-    try accountsdb.registerRPCHooks(&rpc_hooks);
+    try accountsdb.registerRPCHooks(&rpc_hooks, null, expected_slot);
 
     const test_sock_addr = std.net.Address.initIp4(.{ 0, 0, 0, 0 }, 0);
     var server_ctx = try Context.init(.{