feat:add voluntary exit

Signed-off-by: Chen Kai <281165273grape@gmail.com>

Author: GrapeBaBa

src/consensus/altair/types.zig

@@ -38,11 +38,6 @@ pub const LightClientBootstrap = struct {
     current_sync_committee_branch: primitives.CurrentSyncCommitteeBranch,
 };
 
-pub const SignedVoluntaryExit = struct {
-    message: consensus.VoluntaryExit,
-    signature: primitives.BLSSignature,
-};
-
 pub const SyncAggregate = struct {
     sync_committee_bits: []bool,
     sync_committee_signature: primitives.BLSSignature,
@@ -198,15 +193,6 @@ test "test BeaconBlockBody" {
     try std.testing.expectEqual(body.randao_reveal.len, 96);
 }
 
-test "test SignedVoluntaryExit" {
-    const exit = SignedVoluntaryExit{
-        .message = undefined,
-        .signature = undefined,
-    };
-
-    try std.testing.expectEqual(exit.message, undefined);
-}
-
 test "test SyncAggregate" {
     const aggregate = SyncAggregate{
         .sync_committee_bits = &[_]bool{},

src/consensus/helpers/validator.zig

@@ -487,6 +487,16 @@ pub fn switchToCompoundingValidator(state: *consensus.BeaconState, index: primit
     }
 }
 
+pub fn getPendingBalanceToWithdraw(state: *const consensus.BeaconState, validator_index: primitives.ValidatorIndex) primitives.Gwei {
+    var total: primitives.Gwei = 0;
+    for (state.pendingPartialWithdrawals()) |withdrawal| {
+        if (withdrawal.index() == validator_index) {
+            total += withdrawal.amount();
+        }
+    }
+    return total;
+}
+
 test "test getBalanceChurnLimit" {
     preset.ActivePreset.set(preset.Presets.minimal);
     defer preset.ActivePreset.reset();

src/consensus/helpers/voluntary_exit.zig

@@ -0,0 +1,89 @@
+const std = @import("std");
+const primitives = @import("../../primitives/types.zig");
+const consensus = @import("../../consensus/types.zig");
+const configs = @import("../../configs/config.zig");
+const constants = @import("../../primitives/constants.zig");
+const preset = @import("../../presets/preset.zig");
+const phase0 = @import("../../consensus/phase0/types.zig");
+const altair = @import("../../consensus/altair/types.zig");
+const electra = @import("../../consensus/electra/types.zig");
+const validator_helper = @import("../../consensus/helpers/validator.zig");
+const epoch_helper = @import("../../consensus/helpers/epoch.zig");
+const domain_helper = @import("../../consensus/helpers/domain.zig");
+const signing_root_helper = @import("../../consensus/helpers/signing_root.zig");
+const bls_helper = @import("../../consensus/helpers/bls.zig");
+
+/// processVoluntaryExit processes a voluntary exit.
+///
+/// Spec pseudocode definition:
+/// def process_voluntary_exit(state: BeaconState, signed_voluntary_exit: SignedVoluntaryExit) -> None:
+///     voluntary_exit = signed_voluntary_exit.message
+///     validator = state.validators[voluntary_exit.validator_index]
+///     # Verify the validator is active
+///     assert is_active_validator(validator, get_current_epoch(state))
+///     # Verify exit has not been initiated
+///     assert validator.exit_epoch == FAR_FUTURE_EPOCH
+///     # Exits must specify an epoch when they become valid; they are not valid before then
+///     assert get_current_epoch(state) >= voluntary_exit.epoch
+///     # Verify the validator has been active long enough
+///     assert get_current_epoch(state) >= validator.activation_epoch + config.SHARD_COMMITTEE_PERIOD
+///     # Verify signature
+///     # [Modified in Deneb:EIP7044]
+///     domain = compute_domain(DOMAIN_VOLUNTARY_EXIT, config.CAPELLA_FORK_VERSION, state.genesis_validators_root)
+///     signing_root = compute_signing_root(voluntary_exit, domain)
+///     assert bls.Verify(validator.pubkey, signing_root, signed_voluntary_exit.signature)
+///     # Initiate exit
+///     initiate_validator_exit(state, voluntary_exit.validator_index)
+pub fn processVoluntaryExit(state: *consensus.BeaconState, signed_voluntary_exit: *const consensus.SignedVoluntaryExit, allocator: std.mem.Allocator) !void {
+    const voluntary_exit = signed_voluntary_exit.message;
+    const validator = state.validators()[voluntary_exit.validator_index];
+
+    const current_epoch = epoch_helper.getCurrentEpoch(state);
+
+    // Verify the validator is active
+    if (!validator_helper.isActiveValidator(&validator, current_epoch)) {
+        return error.ValidatorNotActive;
+    }
+
+    // Verify exit has not been initiated
+    if (validator.exit_epoch != constants.FAR_FUTURE_EPOCH) {
+        return error.ValidatorExitInitiated;
+    }
+
+    // Exits must specify an epoch when they become valid; they are not valid before then
+    if (current_epoch < voluntary_exit.epoch) {
+        return error.ExitTooEarly;
+    }
+
+    // Verify the validator has been active long enough
+    if (current_epoch < validator.activation_epoch + configs.ActiveConfig.get().SHARD_COMMITTEE_PERIOD) {
+        return error.ValidatorTooYoung;
+    }
+
+    const state_enum = @intFromEnum(state.*);
+    const is_electra_or_later = state_enum >= @intFromEnum(primitives.ForkType.electra);
+    const is_deneb_or_later = state_enum >= @intFromEnum(primitives.ForkType.deneb);
+
+    if (is_electra_or_later) {
+        // Only exit validator if it has no pending withdrawals in the queue
+        const pending_balance = validator_helper.getPendingBalanceToWithdraw(state, voluntary_exit.validator_index);
+        if (pending_balance != 0) {
+            return error.ValidatorHasBalance;
+        }
+    }
+
+    const fork_version = if (is_deneb_or_later)
+        configs.ActiveConfig.get().CAPELLA_FORK_VERSION
+    else
+        null;
+
+    // Verify signature
+    const domain = try domain_helper.computeDomain(constants.DOMAIN_VOLUNTARY_EXIT, fork_version, state.genesisValidatorsRoot(), allocator);
+    const signing_root = try signing_root_helper.computeSigningRoot(&voluntary_exit, &domain, allocator);
+    if (!bls_helper.verify(&validator.pubkey, &signing_root, &signed_voluntary_exit.signature)) {
+        return error.InvalidSignature;
+    }
+
+    // Initiate exit
+    try validator_helper.initiateValidatorExit(state, voluntary_exit.validator_index, allocator);
+}

src/consensus/types.zig

@@ -179,13 +179,9 @@ pub const VoluntaryExit = struct {
     validator_index: primitives.ValidatorIndex,
 };
 
-pub const SignedVoluntaryExit = union(primitives.ForkType) {
-    phase0: NonExistType,
-    altair: altair.SignedVoluntaryExit,
-    bellatrix: altair.SignedVoluntaryExit,
-    capella: altair.SignedVoluntaryExit,
-    deneb: altair.SignedVoluntaryExit,
-    electra: altair.SignedVoluntaryExit,
+pub const SignedVoluntaryExit = struct {
+    message: VoluntaryExit,
+    signature: primitives.BLSSignature,
 };
 
 pub const SignedBeaconBlockHeader = struct {
@@ -530,6 +526,20 @@ pub const PendingPartialWithdrawal = union(primitives.ForkType) {
     capella: NonExistType,
     deneb: NonExistType,
     electra: electra.PendingPartialWithdrawal,
+
+    pub fn index(self: *const PendingPartialWithdrawal) primitives.ValidatorIndex {
+        return switch (self.*) {
+            .phase0, .altair, .bellatrix, .capella, .deneb => @panic("index is not supported for phase0, altair, bellatrix, capella, deneb"),
+            inline else => |withdrawal| withdrawal.index,
+        };
+    }
+
+    pub fn amount(self: *const PendingPartialWithdrawal) primitives.Gwei {
+        return switch (self.*) {
+            .phase0, .altair, .bellatrix, .capella, .deneb => @panic("amount is not supported for phase0, altair, bellatrix, capella, deneb"),
+            inline else => |withdrawal| withdrawal.amount,
+        };
+    }
 };
 
 pub const WithdrawalRequest = union(primitives.ForkType) {
@@ -748,11 +758,19 @@ pub const BeaconState = union(primitives.ForkType) {
     /// pendingBalanceDeposits returns the pending balance deposits of the given state.
     pub fn pendingBalanceDeposit(self: *const BeaconState) []PendingBalanceDeposit {
         return switch (self.*) {
-            .phase0, .altair, .bellatrix, .capella, .deneb => @panic("pending_balance_deposits is not supported for phase0"),
+            .phase0, .altair, .bellatrix, .capella, .deneb => @panic("pending_balance_deposits is not supported for phase0, altair, bellatrix, capella, deneb"),
             inline else => |state| state.pending_balance_deposits,
         };
     }
 
+    /// pendingPartialWithdrawals returns the pending partial withdrawals of the given state.
+    pub fn pendingPartialWithdrawals(self: *const BeaconState) []PendingPartialWithdrawal {
+        return switch (self.*) {
+            .phase0, .altair, .bellatrix, .capella, .deneb => @panic("pending_partial_withdrawals is not supported for phase0, altair, bellatrix, capella, deneb"),
+            inline else => |state| state.pending_partial_withdrawals,
+        };
+    }
+
     /// eth1DepositIndex returns the eth1 deposit index of the given state.
     pub fn eth1DepositIndex(self: *const BeaconState) u64 {
         return switch (self.*) {
@@ -783,23 +801,6 @@ test "test Attestation" {
     try std.testing.expectEqual(attestation1.altair.aggregation_bits.len, 0);
 }
 
-test "test SignedVoluntaryExit" {
-    const exit = SignedVoluntaryExit{
-        .phase0 = NonExistType{},
-    };
-
-    try std.testing.expectEqual(exit.phase0, NonExistType{});
-
-    const exit1 = SignedVoluntaryExit{
-        .altair = altair.SignedVoluntaryExit{
-            .message = undefined,
-            .signature = undefined,
-        },
-    };
-
-    try std.testing.expectEqual(exit1.altair.message, undefined);
-}
-
 test "test SyncAggregate" {
     const aggregate = SyncAggregate{
         .phase0 = NonExistType{},
@@ -1203,3 +1204,12 @@ test "test Validator" {
 
     try std.testing.expectEqual(validator.effective_balance, 0);
 }
+
+test "test SignedVoluntaryExit" {
+    const exit = SignedVoluntaryExit{
+        .message = undefined,
+        .signature = undefined,
+    };
+
+    try std.testing.expectEqual(exit.message, undefined);
+}

src/root.zig

@@ -28,6 +28,7 @@ pub const genesis_helper = @import("consensus/helpers/genesis.zig");
 pub const bls_helper = @import("consensus/helpers/bls.zig");
 pub const bls = @import("./bls/bls.zig");
 pub const deposit_helper = @import("consensus/helpers/deposit.zig");
+pub const voluntary_exit_helper = @import("consensus/helpers/voluntary_exit.zig");
 
 test {
     @import("std").testing.refAllDeclsRecursive(@This());